From db5cb10f1193d5aa4284e8bf4c9e6f207c7ab3d6 Mon Sep 17 00:00:00 2001
From: Dan Siegel <me@dansiegel.net>
Date: Tue, 19 Sep 2023 15:07:06 -0600
Subject: [PATCH 1/5] chore: update Uno.Extensions.Markup

---
 .../Uno.Material.WinUI.Markup.csproj                          | 4 ++--
 .../Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj b/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj
index 53d4a4914..88dc98ed5 100644
--- a/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj
+++ b/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="MSBuild.Sdk.Extras/3.0.44">
+<Project Sdk="MSBuild.Sdk.Extras/3.0.44">
 
 	<!--
 	Adding project references to this project requires some manual adjustments.
@@ -19,7 +19,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Uno.Extensions.Markup.Generators" PrivateAssets="All" Version="1.0.0-dev.187" />
+		<PackageReference Include="Uno.Extensions.Markup.Generators" PrivateAssets="All" Version="5.0.0-dev.394" />
 	</ItemGroup>
 
 	<PropertyGroup>
diff --git a/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj b/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj
index 41e59e047..f4b125f7e 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj
+++ b/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="MSBuild.Sdk.Extras/3.0.44">
+<Project Sdk="MSBuild.Sdk.Extras/3.0.44">
 
 	<!--
 	Adding project references to this project requires some manual adjustments.
@@ -14,7 +14,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Uno.WinUI.Markup" Version="4.7.0-dev.19" />
+		<PackageReference Include="Uno.WinUI.Markup" Version="5.0.0-dev.394" />
 	</ItemGroup>
 
 	<PropertyGroup>

From c44c55010cb17742eeb0230e02f96b8e47d25aa0 Mon Sep 17 00:00:00 2001
From: Dan Siegel <me@dansiegel.net>
Date: Tue, 19 Sep 2023 15:12:31 -0600
Subject: [PATCH 2/5] chore: update to use ResourceKey from C# Markup

---
 .../Uno.Themes.WinUI.Markup/ResourceValue.cs  |  25 -
 .../Uno.Themes.WinUI.Markup/Theme.Brushes.cs  | 620 +++++++++---------
 .../Uno.Themes.WinUI.Markup/Theme.Colors.cs   |  64 +-
 .../Uno.Themes.WinUI.Markup/Theme.Styles.cs   |  90 +--
 4 files changed, 387 insertions(+), 412 deletions(-)
 delete mode 100644 src/library/Uno.Themes.WinUI.Markup/ResourceValue.cs

diff --git a/src/library/Uno.Themes.WinUI.Markup/ResourceValue.cs b/src/library/Uno.Themes.WinUI.Markup/ResourceValue.cs
deleted file mode 100644
index cedcdc9f4..000000000
--- a/src/library/Uno.Themes.WinUI.Markup/ResourceValue.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using System;
-using Microsoft.UI.Xaml;
-using Uno.Extensions.Markup;
-
-
-namespace Uno.Themes.Markup
-{
-	public struct ResourceValue<T>
-	{
-		public ResourceValue(string key, bool isThemeResource = false)
-		{
-			Key = key;
-			IsThemeResource = isThemeResource;
-		}
-
-		public string Key { get; }
-
-		public bool IsThemeResource { get; }
-
-		public static implicit operator Action<IDependencyPropertyBuilder<T>>(ResourceValue<T> resource) =>
-			resource.IsThemeResource ?
-				ThemeResource.Get<T>(resource.Key)
-				: StaticResource.Get<T>(resource.Key);
-	}
-}
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs b/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs
index 6529be6fc..9d43f30a8 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs
@@ -10,1022 +10,1022 @@ public static class Brushes
 			public static class Primary
 			{
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryBrush")]
-				public static ResourceValue<Brush> Default => new("PrimaryBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("PrimaryBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("PrimaryHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("PrimaryHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("PrimaryFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("PrimaryFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("PrimaryPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("PrimaryPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("PrimaryDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("PrimaryDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimarySelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("PrimarySelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("PrimarySelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("PrimaryMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("PrimaryMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryLowBrush")]
-				public static ResourceValue<Brush> Low => new("PrimaryLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("PrimaryLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("PrimaryDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("PrimaryDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "PrimaryDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("PrimaryDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("PrimaryDisabledLowBrush");
 
 				public static class Inverse
 				{
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseBrush")]
-					public static ResourceValue<Brush> Default => new("PrimaryInverseBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("PrimaryInverseBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("PrimaryInverseHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("PrimaryInverseHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("PrimaryInverseFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("PrimaryInverseFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInversePressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("PrimaryInversePressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("PrimaryInversePressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("PrimaryInverseDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("PrimaryInverseDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("PrimaryInverseSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("PrimaryInverseSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("PrimaryInverseMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("PrimaryInverseMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseLowBrush")]
-					public static ResourceValue<Brush> Low => new("PrimaryInverseLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("PrimaryInverseLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("PrimaryInverseDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("PrimaryInverseDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryInverseDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("PrimaryInverseDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("PrimaryInverseDisabledLowBrush");
 				}
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerBrush")]
-					public static ResourceValue<Brush> Default => new("PrimaryContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("PrimaryContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("PrimaryContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("PrimaryContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("PrimaryContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("PrimaryContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("PrimaryContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("PrimaryContainerPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("PrimaryContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("PrimaryContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("PrimaryContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("PrimaryContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("PrimaryContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("PrimaryContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("PrimaryContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("PrimaryContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("PrimaryContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("PrimaryContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("PrimaryContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("PrimaryContainerDisabledLowBrush");
 				}
 
 				public static class VariantLight
 				{
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightBrush")]
-					public static ResourceValue<Brush> Default => new("PrimaryVariantLightBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("PrimaryVariantLightBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("PrimaryVariantLightHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("PrimaryVariantLightHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("PrimaryVariantLightFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("PrimaryVariantLightFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("PrimaryVariantLightPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("PrimaryVariantLightPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("PrimaryVariantLightDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("PrimaryVariantLightDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("PrimaryVariantLightSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("PrimaryVariantLightSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("PrimaryVariantLightMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("PrimaryVariantLightMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightLowBrush")]
-					public static ResourceValue<Brush> Low => new("PrimaryVariantLightLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("PrimaryVariantLightLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("PrimaryVariantLightDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("PrimaryVariantLightDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantLightDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("PrimaryVariantLightDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("PrimaryVariantLightDisabledLowBrush");
 				}
 
 				public static class VariantDark
 				{
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkBrush")]
-					public static ResourceValue<Brush> Default => new("PrimaryVariantDarkBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("PrimaryVariantDarkBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("PrimaryVariantDarkHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("PrimaryVariantDarkHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("PrimaryVariantDarkFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("PrimaryVariantDarkFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("PrimaryVariantDarkPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("PrimaryVariantDarkPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("PrimaryVariantDarkDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("PrimaryVariantDarkDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("PrimaryVariantDarkSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("PrimaryVariantDarkSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("PrimaryVariantDarkMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("PrimaryVariantDarkMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkLowBrush")]
-					public static ResourceValue<Brush> Low => new("PrimaryVariantDarkLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("PrimaryVariantDarkLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("PrimaryVariantDarkDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("PrimaryVariantDarkDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "PrimaryVariantDarkDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("PrimaryVariantDarkDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("PrimaryVariantDarkDisabledLowBrush");
 				}
 			}
 
 			public static class OnPrimary
 			{
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryBrush")]
-				public static ResourceValue<Brush> Default => new("OnPrimaryBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("OnPrimaryBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("OnPrimaryHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("OnPrimaryHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("OnPrimaryFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("OnPrimaryFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("OnPrimaryPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("OnPrimaryPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("OnPrimaryDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("OnPrimaryDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimarySelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("OnPrimarySelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("OnPrimarySelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("OnPrimaryMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("OnPrimaryMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryLowBrush")]
-				public static ResourceValue<Brush> Low => new("OnPrimaryLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("OnPrimaryLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("OnPrimaryDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("OnPrimaryDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnPrimaryDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("OnPrimaryDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("OnPrimaryDisabledLowBrush");
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerBrush")]
-					public static ResourceValue<Brush> Default => new("OnPrimaryContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("OnPrimaryContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("OnPrimaryContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("OnPrimaryContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("OnPrimaryContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("OnPrimaryContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("OnPrimaryContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("OnPrimaryContainerPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("OnPrimaryContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("OnPrimaryContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("OnPrimaryContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("OnPrimaryContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("OnPrimaryContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("OnPrimaryContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("OnPrimaryContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("OnPrimaryContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("OnPrimaryContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("OnPrimaryContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnPrimaryContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("OnPrimaryContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("OnPrimaryContainerDisabledLowBrush");
 				}
 			}
 
 			public static class Secondary
 			{
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryBrush")]
-				public static ResourceValue<Brush> Default => new("SecondaryBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("SecondaryBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("SecondaryHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("SecondaryHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("SecondaryFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("SecondaryFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("SecondaryPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("SecondaryPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("SecondaryDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("SecondaryDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondarySelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("SecondarySelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("SecondarySelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("SecondaryMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("SecondaryMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryLowBrush")]
-				public static ResourceValue<Brush> Low => new("SecondaryLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("SecondaryLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("SecondaryDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("SecondaryDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SecondaryDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("SecondaryDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("SecondaryDisabledLowBrush");
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerBrush")]
-					public static ResourceValue<Brush> Default => new("SecondaryContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("SecondaryContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("SecondaryContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("SecondaryContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("SecondaryContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("SecondaryContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("SecondaryContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("SecondaryContainerPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("SecondaryContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("SecondaryContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("SecondaryContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("SecondaryContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("SecondaryContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("SecondaryContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("SecondaryContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("SecondaryContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("SecondaryContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("SecondaryContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("SecondaryContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("SecondaryContainerDisabledLowBrush");
 				}
 
 				public static class VariantLight
 				{
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightBrush")]
-					public static ResourceValue<Brush> Default => new("SecondaryVariantLightBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("SecondaryVariantLightBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("SecondaryVariantLightHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("SecondaryVariantLightHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("SecondaryVariantLightFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("SecondaryVariantLightFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("SecondaryVariantLightPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("SecondaryVariantLightPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("SecondaryVariantLightDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("SecondaryVariantLightDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("SecondaryVariantLightSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("SecondaryVariantLightSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("SecondaryVariantLightMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("SecondaryVariantLightMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightLowBrush")]
-					public static ResourceValue<Brush> Low => new("SecondaryVariantLightLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("SecondaryVariantLightLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("SecondaryVariantLightDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("SecondaryVariantLightDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantLightDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("SecondaryVariantLightDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("SecondaryVariantLightDisabledLowBrush");
 				}
 
 				public static class VariantDark
 				{
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkBrush")]
-					public static ResourceValue<Brush> Default => new("SecondaryVariantDarkBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("SecondaryVariantDarkBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("SecondaryVariantDarkHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("SecondaryVariantDarkHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("SecondaryVariantDarkFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("SecondaryVariantDarkFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("SecondaryVariantDarkPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("SecondaryVariantDarkPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("SecondaryVariantDarkDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("SecondaryVariantDarkDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("SecondaryVariantDarkSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("SecondaryVariantDarkSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("SecondaryVariantDarkMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("SecondaryVariantDarkMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkLowBrush")]
-					public static ResourceValue<Brush> Low => new("SecondaryVariantDarkLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("SecondaryVariantDarkLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("SecondaryVariantDarkDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("SecondaryVariantDarkDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SecondaryVariantDarkDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("SecondaryVariantDarkDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("SecondaryVariantDarkDisabledLowBrush");
 				}
 			}
 
 			public static class OnSecondary
 			{
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryBrush")]
-				public static ResourceValue<Brush> Default => new("OnSecondaryBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("OnSecondaryBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("OnSecondaryHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("OnSecondaryHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("OnSecondaryFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("OnSecondaryFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("OnSecondaryPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("OnSecondaryPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("OnSecondaryDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("OnSecondaryDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondarySelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("OnSecondarySelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("OnSecondarySelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("OnSecondaryMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("OnSecondaryMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryLowBrush")]
-				public static ResourceValue<Brush> Low => new("OnSecondaryLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("OnSecondaryLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("OnSecondaryDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("OnSecondaryDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSecondaryDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("OnSecondaryDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("OnSecondaryDisabledLowBrush");
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerBrush")]
-					public static ResourceValue<Brush> Default => new("OnSecondaryContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("OnSecondaryContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("OnSecondaryContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("OnSecondaryContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("OnSecondaryContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("OnSecondaryContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("OnSecondaryContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("OnSecondaryContainerPressedBrush");
 
-					public static ResourceValue<Brush> Dragged => new("OnSecondaryContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("OnSecondaryContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("OnSecondaryContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("OnSecondaryContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("OnSecondaryContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("OnSecondaryContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("OnSecondaryContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("OnSecondaryContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("OnSecondaryContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("OnSecondaryContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSecondaryContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("OnSecondaryContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("OnSecondaryContainerDisabledLowBrush");
 				}
 			}
 
 			public static class Tertiary
 			{
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryBrush")]
-				public static ResourceValue<Brush> Default => new("TertiaryBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("TertiaryBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("TertiaryHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("TertiaryHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("TertiaryFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("TertiaryFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("TertiaryPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("TertiaryPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("TertiaryDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("TertiaryDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiarySelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("TertiarySelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("TertiarySelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("TertiaryMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("TertiaryMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryLowBrush")]
-				public static ResourceValue<Brush> Low => new("TertiaryLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("TertiaryLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("TertiaryDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("TertiaryDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "TertiaryDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("TertiaryDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("TertiaryDisabledLowBrush");
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerBrush")]
-					public static ResourceValue<Brush> Default => new("TertiaryContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("TertiaryContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("TertiaryContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("TertiaryContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("TertiaryContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("TertiaryContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("TertiaryContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("TertiaryContainerPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("TertiaryContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("TertiaryContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("TertiaryContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("TertiaryContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("TertiaryContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("TertiaryContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("TertiaryContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("TertiaryContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("TertiaryContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("TertiaryContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "TertiaryContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("TertiaryContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("TertiaryContainerDisabledLowBrush");
 				}
 			}
 
 			public static class OnTertiary
 			{
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryBrush")]
-				public static ResourceValue<Brush> Default => new("OnTertiaryBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("OnTertiaryBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("OnTertiaryHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("OnTertiaryHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("OnTertiaryFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("OnTertiaryFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("OnTertiaryPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("OnTertiaryPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("OnTertiaryDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("OnTertiaryDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiarySelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("OnTertiarySelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("OnTertiarySelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("OnTertiaryMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("OnTertiaryMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryLowBrush")]
-				public static ResourceValue<Brush> Low => new("OnTertiaryLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("OnTertiaryLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("OnTertiaryDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("OnTertiaryDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnTertiaryDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("OnTertiaryDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("OnTertiaryDisabledLowBrush");
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerBrush")]
-					public static ResourceValue<Brush> Default => new("OnTertiaryContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("OnTertiaryContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("OnTertiaryContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("OnTertiaryContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("OnTertiaryContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("OnTertiaryContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("OnTertiaryContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("OnTertiaryContainerPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("OnTertiaryContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("OnTertiaryContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("OnTertiaryContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("OnTertiaryContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("OnTertiaryContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("OnTertiaryContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("OnTertiaryContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("OnTertiaryContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("OnTertiaryContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("OnTertiaryContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnTertiaryContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("OnTertiaryContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("OnTertiaryContainerDisabledLowBrush");
 				}
 			}
 
 			public static class Error
 			{
 				[ResourceKeyDefinition(typeof(Brush), "ErrorBrush")]
-				public static ResourceValue<Brush> Default => new("ErrorBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("ErrorBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("ErrorHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("ErrorHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("ErrorFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("ErrorFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("ErrorPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("ErrorPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("ErrorDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("ErrorDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorSelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("ErrorSelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("ErrorSelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("ErrorMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("ErrorMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorLowBrush")]
-				public static ResourceValue<Brush> Low => new("ErrorLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("ErrorLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("ErrorDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("ErrorDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "ErrorDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("ErrorDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("ErrorDisabledLowBrush");
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerBrush")]
-					public static ResourceValue<Brush> Default => new("ErrorContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("ErrorContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("ErrorContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("ErrorContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("ErrorContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("ErrorContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("ErrorContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("ErrorContainerPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("ErrorContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("ErrorContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("ErrorContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("ErrorContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("ErrorContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("ErrorContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("ErrorContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("ErrorContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("ErrorContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("ErrorContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "ErrorContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("ErrorContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("ErrorContainerDisabledLowBrush");
 				}
 			}
 
 			public static class OnError
 			{
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorBrush")]
-				public static ResourceValue<Brush> Default => new("OnErrorBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("OnErrorBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("OnErrorHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("OnErrorHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("OnErrorFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("OnErrorFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("OnErrorPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("OnErrorPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("OnErrorDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("OnErrorDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorSelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("OnErrorSelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("OnErrorSelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("OnErrorMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("OnErrorMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorLowBrush")]
-				public static ResourceValue<Brush> Low => new("OnErrorLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("OnErrorLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("OnErrorDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("OnErrorDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnErrorDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("OnErrorDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("OnErrorDisabledLowBrush");
 
 				public static class Container
 				{
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerBrush")]
-					public static ResourceValue<Brush> Default => new("OnErrorContainerBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("OnErrorContainerBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("OnErrorContainerHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("OnErrorContainerHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("OnErrorContainerFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("OnErrorContainerFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("OnErrorContainerPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("OnErrorContainerPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("OnErrorContainerDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("OnErrorContainerDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("OnErrorContainerSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("OnErrorContainerSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("OnErrorContainerMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("OnErrorContainerMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerLowBrush")]
-					public static ResourceValue<Brush> Low => new("OnErrorContainerLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("OnErrorContainerLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("OnErrorContainerDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("OnErrorContainerDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnErrorContainerDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("OnErrorContainerDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("OnErrorContainerDisabledLowBrush");
 				}
 			}
 
 			public static class Background
 			{
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundBrush")]
-				public static ResourceValue<Brush> Default => new("BackgroundBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("BackgroundBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("BackgroundHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("BackgroundHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("BackgroundFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("BackgroundFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("BackgroundPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("BackgroundPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("BackgroundDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("BackgroundDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundSelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("BackgroundSelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("BackgroundSelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("BackgroundMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("BackgroundMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundLowBrush")]
-				public static ResourceValue<Brush> Low => new("BackgroundLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("BackgroundLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("BackgroundDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("BackgroundDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "BackgroundDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("BackgroundDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("BackgroundDisabledLowBrush");
 			}
 
 			public static class OnBackground
 			{
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundBrush")]
-				public static ResourceValue<Brush> Default => new("OnBackgroundBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("OnBackgroundBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("OnBackgroundHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("OnBackgroundHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("OnBackgroundFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("OnBackgroundFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundPressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("OnBackgroundPressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("OnBackgroundPressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("OnBackgroundDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("OnBackgroundDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundSelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("OnBackgroundSelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("OnBackgroundSelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("OnBackgroundMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("OnBackgroundMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundLowBrush")]
-				public static ResourceValue<Brush> Low => new("OnBackgroundLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("OnBackgroundLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("OnBackgroundDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("OnBackgroundDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnBackgroundDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("OnBackgroundDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("OnBackgroundDisabledLowBrush");
 			}
 
 			public static class Surface
 			{
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceBrush")]
-				public static ResourceValue<Brush> Default => new("SurfaceBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("SurfaceBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("SurfaceHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("SurfaceHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("SurfaceFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("SurfaceFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfacePressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("SurfacePressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("SurfacePressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("SurfaceDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("SurfaceDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceSelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("SurfaceSelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("SurfaceSelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("SurfaceMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("SurfaceMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceLowBrush")]
-				public static ResourceValue<Brush> Low => new("SurfaceLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("SurfaceLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("SurfaceDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("SurfaceDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "SurfaceDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("SurfaceDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("SurfaceDisabledLowBrush");
 
 				public static class Variant
 				{
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantBrush")]
-					public static ResourceValue<Brush> Default => new("SurfaceVariantBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("SurfaceVariantBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("SurfaceVariantHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("SurfaceVariantHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("SurfaceVariantFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("SurfaceVariantFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("SurfaceVariantPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("SurfaceVariantPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("SurfaceVariantDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("SurfaceVariantDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("SurfaceVariantSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("SurfaceVariantSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("SurfaceVariantMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("SurfaceVariantMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantLowBrush")]
-					public static ResourceValue<Brush> Low => new("SurfaceVariantLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("SurfaceVariantLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("SurfaceVariantDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("SurfaceVariantDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceVariantDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("SurfaceVariantDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("SurfaceVariantDisabledLowBrush");
 				}
 
 				public static class Inverse
 				{
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseBrush")]
-					public static ResourceValue<Brush> Default => new("SurfaceInverseBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("SurfaceInverseBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("SurfaceInverseHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("SurfaceInverseHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("SurfaceInverseFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("SurfaceInverseFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInversePressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("SurfaceInversePressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("SurfaceInversePressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("SurfaceInverseDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("SurfaceInverseDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("SurfaceInverseSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("SurfaceInverseSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("SurfaceInverseMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("SurfaceInverseMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseLowBrush")]
-					public static ResourceValue<Brush> Low => new("SurfaceInverseLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("SurfaceInverseLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("SurfaceInverseDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("SurfaceInverseDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "SurfaceInverseDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("SurfaceInverseDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("SurfaceInverseDisabledLowBrush");
 				}
 			}
 
 			public static class OnSurface
 			{
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceBrush")]
-				public static ResourceValue<Brush> Default => new("OnSurfaceBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("OnSurfaceBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("OnSurfaceHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("OnSurfaceHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("OnSurfaceFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("OnSurfaceFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfacePressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("OnSurfacePressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("OnSurfacePressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("OnSurfaceDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("OnSurfaceDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceSelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("OnSurfaceSelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("OnSurfaceSelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("OnSurfaceMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("OnSurfaceMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceLowBrush")]
-				public static ResourceValue<Brush> Low => new("OnSurfaceLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("OnSurfaceLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("OnSurfaceDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("OnSurfaceDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OnSurfaceDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("OnSurfaceDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("OnSurfaceDisabledLowBrush");
 
 				public static class Variant
 				{
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantBrush")]
-					public static ResourceValue<Brush> Default => new("OnSurfaceVariantBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("OnSurfaceVariantBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("OnSurfaceVariantHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("OnSurfaceVariantHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("OnSurfaceVariantFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("OnSurfaceVariantFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("OnSurfaceVariantPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("OnSurfaceVariantPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("OnSurfaceVariantDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("OnSurfaceVariantDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("OnSurfaceVariantSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("OnSurfaceVariantSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("OnSurfaceVariantMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("OnSurfaceVariantMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantLowBrush")]
-					public static ResourceValue<Brush> Low => new("OnSurfaceVariantLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("OnSurfaceVariantLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("OnSurfaceVariantDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("OnSurfaceVariantDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceVariantDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("OnSurfaceVariantDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("OnSurfaceVariantDisabledLowBrush");
 				}
 
 				public static class Inverse
 				{
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseBrush")]
-					public static ResourceValue<Brush> Default => new("OnSurfaceInverseBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("OnSurfaceInverseBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("OnSurfaceInverseHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("OnSurfaceInverseHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("OnSurfaceInverseFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("OnSurfaceInverseFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInversePressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("OnSurfaceInversePressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("OnSurfaceInversePressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("OnSurfaceInverseDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("OnSurfaceInverseDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("OnSurfaceInverseSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("OnSurfaceInverseSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("OnSurfaceInverseMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("OnSurfaceInverseMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseLowBrush")]
-					public static ResourceValue<Brush> Low => new("OnSurfaceInverseLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("OnSurfaceInverseLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("OnSurfaceInverseDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("OnSurfaceInverseDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OnSurfaceInverseDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("OnSurfaceInverseDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("OnSurfaceInverseDisabledLowBrush");
 				}
 			}
 
 			public static class Outline
 			{
 				[ResourceKeyDefinition(typeof(Brush), "OutlineBrush")]
-				public static ResourceValue<Brush> Default => new("OutlineBrush", true);
+				public static ThemeResourceKey<Brush> Default => new("OutlineBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineHoverBrush")]
-				public static ResourceValue<Brush> Hover => new("OutlineHoverBrush", true);
+				public static ThemeResourceKey<Brush> Hover => new("OutlineHoverBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineFocusedBrush")]
-				public static ResourceValue<Brush> Focused => new("OutlineFocusedBrush", true);
+				public static ThemeResourceKey<Brush> Focused => new("OutlineFocusedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlinePressedBrush")]
-				public static ResourceValue<Brush> Pressed => new("OutlinePressedBrush", true);
+				public static ThemeResourceKey<Brush> Pressed => new("OutlinePressedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineDraggedBrush")]
-				public static ResourceValue<Brush> Dragged => new("OutlineDraggedBrush", true);
+				public static ThemeResourceKey<Brush> Dragged => new("OutlineDraggedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineSelectedBrush")]
-				public static ResourceValue<Brush> Selected => new("OutlineSelectedBrush", true);
+				public static ThemeResourceKey<Brush> Selected => new("OutlineSelectedBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineMediumBrush")]
-				public static ResourceValue<Brush> Medium => new("OutlineMediumBrush", true);
+				public static ThemeResourceKey<Brush> Medium => new("OutlineMediumBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineLowBrush")]
-				public static ResourceValue<Brush> Low => new("OutlineLowBrush", true);
+				public static ThemeResourceKey<Brush> Low => new("OutlineLowBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineDisabledBrush")]
-				public static ResourceValue<Brush> Disabled => new("OutlineDisabledBrush", true);
+				public static ThemeResourceKey<Brush> Disabled => new("OutlineDisabledBrush");
 
 				[ResourceKeyDefinition(typeof(Brush), "OutlineDisabledLowBrush")]
-				public static ResourceValue<Brush> DisabledLow => new("OutlineDisabledLowBrush", true);
+				public static ThemeResourceKey<Brush> DisabledLow => new("OutlineDisabledLowBrush");
 
 				public static class Variant
 				{
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantBrush")]
-					public static ResourceValue<Brush> Default => new("OutlineVariantBrush", true);
+					public static ThemeResourceKey<Brush> Default => new("OutlineVariantBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantHoverBrush")]
-					public static ResourceValue<Brush> Hover => new("OutlineVariantHoverBrush", true);
+					public static ThemeResourceKey<Brush> Hover => new("OutlineVariantHoverBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantFocusedBrush")]
-					public static ResourceValue<Brush> Focused => new("OutlineVariantFocusedBrush", true);
+					public static ThemeResourceKey<Brush> Focused => new("OutlineVariantFocusedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantPressedBrush")]
-					public static ResourceValue<Brush> Pressed => new("OutlineVariantPressedBrush", true);
+					public static ThemeResourceKey<Brush> Pressed => new("OutlineVariantPressedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantDraggedBrush")]
-					public static ResourceValue<Brush> Dragged => new("OutlineVariantDraggedBrush", true);
+					public static ThemeResourceKey<Brush> Dragged => new("OutlineVariantDraggedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantSelectedBrush")]
-					public static ResourceValue<Brush> Selected => new("OutlineVariantSelectedBrush", true);
+					public static ThemeResourceKey<Brush> Selected => new("OutlineVariantSelectedBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantMediumBrush")]
-					public static ResourceValue<Brush> Medium => new("OutlineVariantMediumBrush", true);
+					public static ThemeResourceKey<Brush> Medium => new("OutlineVariantMediumBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantLowBrush")]
-					public static ResourceValue<Brush> Low => new("OutlineVariantLowBrush", true);
+					public static ThemeResourceKey<Brush> Low => new("OutlineVariantLowBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantDisabledBrush")]
-					public static ResourceValue<Brush> Disabled => new("OutlineVariantDisabledBrush", true);
+					public static ThemeResourceKey<Brush> Disabled => new("OutlineVariantDisabledBrush");
 
 					[ResourceKeyDefinition(typeof(Brush), "OutlineVariantDisabledLowBrush")]
-					public static ResourceValue<Brush> DisabledLow => new("OutlineVariantDisabledLowBrush", true);
+					public static ThemeResourceKey<Brush> DisabledLow => new("OutlineVariantDisabledLowBrush");
 				}
 			}
 		}
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs b/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs
index c36edd440..b6514a3c4 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs
@@ -10,136 +10,136 @@ public static class Colors
 			public static class Primary
 			{
 				[ResourceKeyDefinition(typeof(Color), "PrimaryColor")]
-				public static ResourceValue<Color> Default => new("PrimaryColor", true);
+				public static ThemeResourceKey<Color> Default => new("PrimaryColor");
 
 				[ResourceKeyDefinition(typeof(Color), "PrimaryInverseColor")]
-				public static ResourceValue<Color> Inverse => new("PrimaryInverseColor", true);
+				public static ThemeResourceKey<Color> Inverse => new("PrimaryInverseColor");
 
 				[ResourceKeyDefinition(typeof(Color), "PrimaryContainerColor")]
-				public static ResourceValue<Color> Container => new("PrimaryContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("PrimaryContainerColor");
 
 				[ResourceKeyDefinition(typeof(Color), "PrimaryVariantDarkColor")]
-				public static ResourceValue<Color> VariantDark => new("PrimaryVariantDarkColor", true);
+				public static ThemeResourceKey<Color> VariantDark => new("PrimaryVariantDarkColor");
 
 				[ResourceKeyDefinition(typeof(Color), "PrimaryVariantLightColor")]
-				public static ResourceValue<Color> VariantLight => new("PrimaryVariantLightColor", true);
+				public static ThemeResourceKey<Color> VariantLight => new("PrimaryVariantLightColor");
 			}
 
 			public static class OnPrimary
 			{
 				[ResourceKeyDefinition(typeof(Color), "OnPrimaryColor")]
-				public static ResourceValue<Color> Default => new("OnPrimaryColor", true);
+				public static ThemeResourceKey<Color> Default => new("OnPrimaryColor");
 
 				[ResourceKeyDefinition(typeof(Color), "OnPrimaryContainerColor")]
-				public static ResourceValue<Color> Container => new("OnPrimaryContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("OnPrimaryContainerColor");
 			}
 
 			public static class Secondary
 			{
 				[ResourceKeyDefinition(typeof(Color), "SecondaryColor")]
-				public static ResourceValue<Color> Default => new("SecondaryColor", true);
+				public static ThemeResourceKey<Color> Default => new("SecondaryColor");
 
 				[ResourceKeyDefinition(typeof(Color), "SecondaryContainerColor")]
-				public static ResourceValue<Color> Container => new("SecondaryContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("SecondaryContainerColor");
 
 				[ResourceKeyDefinition(typeof(Color), "SecondaryVariantDarkColor")]
-				public static ResourceValue<Color> VariantDark => new("SecondaryVariantDarkColor", true);
+				public static ThemeResourceKey<Color> VariantDark => new("SecondaryVariantDarkColor");
 
 				[ResourceKeyDefinition(typeof(Color), "SecondaryVariantLightColor")]
-				public static ResourceValue<Color> VariantLight => new("SecondaryVariantLightColor", true);
+				public static ThemeResourceKey<Color> VariantLight => new("SecondaryVariantLightColor");
 			}
 
 			public static class OnSecondary
 			{
 				[ResourceKeyDefinition(typeof(Color), "OnSecondaryColor")]
-				public static ResourceValue<Color> Default => new("OnSecondaryColor", true);
+				public static ThemeResourceKey<Color> Default => new("OnSecondaryColor");
 
 				[ResourceKeyDefinition(typeof(Color), "OnSecondaryContainerColor")]
-				public static ResourceValue<Color> Container => new("OnSecondaryContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("OnSecondaryContainerColor");
 			}
 
 			public static class Tertiary
 			{
 				[ResourceKeyDefinition(typeof(Color), "TertiaryColor")]
-				public static ResourceValue<Color> Default => new("TertiaryColor", true);
+				public static ThemeResourceKey<Color> Default => new("TertiaryColor");
 
 				[ResourceKeyDefinition(typeof(Color), "TertiaryContainerColor")]
-				public static ResourceValue<Color> Container => new("TertiaryContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("TertiaryContainerColor");
 			}
 
 			public static class OnTertiary
 			{
 				[ResourceKeyDefinition(typeof(Color), "OnTertiaryColor")]
-				public static ResourceValue<Color> Default => new("OnTertiaryColor", true);
+				public static ThemeResourceKey<Color> Default => new("OnTertiaryColor");
 
 				[ResourceKeyDefinition(typeof(Color), "OnTertiaryContainerColor")]
-				public static ResourceValue<Color> Container => new("OnTertiaryContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("OnTertiaryContainerColor");
 			}
 
 			public static class Error
 			{
 				[ResourceKeyDefinition(typeof(Color), "ErrorColor")]
-				public static ResourceValue<Color> Default => new("ErrorColor", true);
+				public static ThemeResourceKey<Color> Default => new("ErrorColor");
 
 				[ResourceKeyDefinition(typeof(Color), "ErrorContainerColor")]
-				public static ResourceValue<Color> Container => new("ErrorContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("ErrorContainerColor");
 			}
 
 			public static class OnError
 			{
 				[ResourceKeyDefinition(typeof(Color), "OnErrorColor")]
-				public static ResourceValue<Color> Default => new("OnErrorColor", true);
+				public static ThemeResourceKey<Color> Default => new("OnErrorColor");
 
 				[ResourceKeyDefinition(typeof(Color), "OnErrorContainerColor")]
-				public static ResourceValue<Color> Container => new("OnErrorContainerColor", true);
+				public static ThemeResourceKey<Color> Container => new("OnErrorContainerColor");
 			}
 
 			public static class Background
 			{
 				[ResourceKeyDefinition(typeof(Color), "BackgroundColor")]
-				public static ResourceValue<Color> Default => new("BackgroundColor", true);
+				public static ThemeResourceKey<Color> Default => new("BackgroundColor");
 			}
 
 			public static class OnBackground
 			{
 				[ResourceKeyDefinition(typeof(Color), "OnBackgroundColor")]
-				public static ResourceValue<Color> Default => new("OnBackgroundColor", true);
+				public static ThemeResourceKey<Color> Default => new("OnBackgroundColor");
 			}
 
 			public static class Surface
 			{
 				[ResourceKeyDefinition(typeof(Color), "SurfaceColor")]
-				public static ResourceValue<Color> Default => new("SurfaceColor", true);
+				public static ThemeResourceKey<Color> Default => new("SurfaceColor");
 
 				[ResourceKeyDefinition(typeof(Color), "SurfaceVariantColor")]
-				public static ResourceValue<Color> Variant => new("SurfaceVariantColor", true);
+				public static ThemeResourceKey<Color> Variant => new("SurfaceVariantColor");
 
 				[ResourceKeyDefinition(typeof(Color), "SurfaceInverseColor")]
-				public static ResourceValue<Color> Inverse => new("SurfaceInverseColor", true);
+				public static ThemeResourceKey<Color> Inverse => new("SurfaceInverseColor");
 
 				[ResourceKeyDefinition(typeof(Color), "SurfaceTintColor")]
-				public static ResourceValue<Color> Tint => new("SurfaceTintColor", true);
+				public static ThemeResourceKey<Color> Tint => new("SurfaceTintColor");
 			}
 
 			public static class OnSurface
 			{
 				[ResourceKeyDefinition(typeof(Color), "OnSurfaceColor")]
-				public static ResourceValue<Color> Default => new("OnSurfaceColor", true);
+				public static ThemeResourceKey<Color> Default => new("OnSurfaceColor");
 
 				[ResourceKeyDefinition(typeof(Color), "OnSurfaceVariantColor")]
-				public static ResourceValue<Color> Variant => new("OnSurfaceVariantColor", true);
+				public static ThemeResourceKey<Color> Variant => new("OnSurfaceVariantColor");
 
 				[ResourceKeyDefinition(typeof(Color), "OnSurfaceInverseColor")]
-				public static ResourceValue<Color> Inverse => new("OnSurfaceInverseColor", true);
+				public static ThemeResourceKey<Color> Inverse => new("OnSurfaceInverseColor");
 			}
 
 			public static class Outline
 			{
 				[ResourceKeyDefinition(typeof(Color), "OutlineColor")]
-				public static ResourceValue<Color> Default => new("OutlineColor", true);
+				public static ThemeResourceKey<Color> Default => new("OutlineColor");
 
 				[ResourceKeyDefinition(typeof(Color), "OutlineVariantColor")]
-				public static ResourceValue<Color> Variant => new ("OutlineVariantColor", true);
+				public static ThemeResourceKey<Color> Variant => new ("OutlineVariantColor");
 			}
 
 		}
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs b/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs
index 1d74554b6..a3f105a81 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs
@@ -10,205 +10,205 @@ public static class Styles
 			public static class CalendarDatePicker
 			{
 				[ResourceKeyDefinition(typeof(Style), "CalendarDatePickerStyle", TargetType = typeof(CalendarDatePicker))]
-				public static ResourceValue<Style> Default => new("CalendarDatePickerStyle");
+				public static StaticResourceKey<Style> Default => new("CalendarDatePickerStyle");
 			}
 
 			public static class CalendarView
 			{
 				[ResourceKeyDefinition(typeof(Style), "CalendarViewStyle", TargetType = typeof(CalendarView))]
-				public static ResourceValue<Style> Default => new("CalendarViewStyle");
+				public static StaticResourceKey<Style> Default => new("CalendarViewStyle");
 			}
 
 			public static class CheckBox
 			{
 				[ResourceKeyDefinition(typeof(Style), "CheckBoxStyle", TargetType = typeof(CheckBox))]
-				public static ResourceValue<Style> Default => new("CheckBoxStyle");
+				public static StaticResourceKey<Style> Default => new("CheckBoxStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SecondaryCheckBoxStyle", TargetType = typeof(CheckBox))]
-				public static ResourceValue<Style> Secondary => new("SecondaryCheckBoxStyle");
+				public static StaticResourceKey<Style> Secondary => new("SecondaryCheckBoxStyle");
 			}
 
 			public static class AppBarButton
 			{
 				[ResourceKeyDefinition(typeof(Style), "AppBarButtonStyle", TargetType = typeof(AppBarButton))]
-				public static ResourceValue<Style> Default => new("AppBarButtonStyle");
+				public static StaticResourceKey<Style> Default => new("AppBarButtonStyle");
 			}
 
 			public static class CommandBar
 			{
 				[ResourceKeyDefinition(typeof(Style), "CommandBarStyle", TargetType = typeof(CommandBar))]
-				public static ResourceValue<Style> Default => new("CommandBarStyle");
+				public static StaticResourceKey<Style> Default => new("CommandBarStyle");
 			}
 
 			public static class ContentDialog
 			{
 				[ResourceKeyDefinition(typeof(Style), "ContentDialogStyle", TargetType = typeof(ContentDialog))]
-				public static ResourceValue<Style> Default => new("ContentDialogStyle");
+				public static StaticResourceKey<Style> Default => new("ContentDialogStyle");
 			}
 
 			public static class DatePicker
 			{
 				[ResourceKeyDefinition(typeof(Style), "DatePickerStyle", TargetType = typeof(DatePicker))]
-				public static ResourceValue<Style> Default => new("DatePickerStyle");
+				public static StaticResourceKey<Style> Default => new("DatePickerStyle");
 			}
 
 			public static class FlyoutPresenter
 			{
 				[ResourceKeyDefinition(typeof(Style), "FlyoutPresenterStyle", TargetType = typeof(FlyoutPresenter))]
-				public static ResourceValue<Style> Default => new("FlyoutPresenterStyle");
+				public static StaticResourceKey<Style> Default => new("FlyoutPresenterStyle");
 			}
 
 			public static class MenuFlyoutItem
 			{
 				[ResourceKeyDefinition(typeof(Style), "MenuFlyoutItemStyle", TargetType = typeof(MenuFlyoutItem))]
-				public static ResourceValue<Style> Default => new("MenuFlyoutItemStyle");
+				public static StaticResourceKey<Style> Default => new("MenuFlyoutItemStyle");
 			}
 
 			public static class MenuFlyoutPresenter
 			{
 				[ResourceKeyDefinition(typeof(Style), "MenuFlyoutPresenterStyle", TargetType = typeof(MenuFlyoutPresenter))]
-				public static ResourceValue<Style> Default => new("MenuFlyoutPresenterStyle");
+				public static StaticResourceKey<Style> Default => new("MenuFlyoutPresenterStyle");
 			}
 
 			public static class HyperlinkButton
 			{
 				[ResourceKeyDefinition(typeof(Style), "HyperlinkButtonStyle", TargetType = typeof(HyperlinkButton))]
-				public static ResourceValue<Style> Default => new("HyperlinkButtonStyle");
+				public static StaticResourceKey<Style> Default => new("HyperlinkButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SecondaryHyperlinkButtonStyle", TargetType = typeof(HyperlinkButton))]
-				public static ResourceValue<Style> Secondary => new("SecondaryHyperlinkButtonStyle");
+				public static StaticResourceKey<Style> Secondary => new("SecondaryHyperlinkButtonStyle");
 			}
 
 			public static class ListViewItem
 			{
 				[ResourceKeyDefinition(typeof(Style), "ListViewItemStyle", TargetType = typeof(ListViewItem))]
-				public static ResourceValue<Style> Default => new("ListViewItemStyle");
+				public static StaticResourceKey<Style> Default => new("ListViewItemStyle");
 			}
 
 			public static class ListView
 			{
 				[ResourceKeyDefinition(typeof(Style), "ListViewStyle", TargetType = typeof(ListView))]
-				public static ResourceValue<Style> Default => new("ListViewStyle");
+				public static StaticResourceKey<Style> Default => new("ListViewStyle");
 			}
 
 			public static class NavigationView
 			{
 				[ResourceKeyDefinition(typeof(Style), "NavigationViewStyle", TargetType = typeof(NavigationView))]
-				public static ResourceValue<Style> Default => new("NavigationViewStyle");
+				public static StaticResourceKey<Style> Default => new("NavigationViewStyle");
 			}
 
 			public static class NavigationViewItem
 			{
 				[ResourceKeyDefinition(typeof(Style), "NavigationViewItemStyle", TargetType = typeof(NavigationViewItem))]
-				public static ResourceValue<Style> Default => new("NavigationViewItemStyle");
+				public static StaticResourceKey<Style> Default => new("NavigationViewItemStyle");
 			}
 
 			public static class PipsPager
 			{
 				[ResourceKeyDefinition(typeof(Style), "PipsPagerStyle", TargetType = typeof(PipsPager))]
-				public static ResourceValue<Style> Default => new("PipsPagerStyle");
+				public static StaticResourceKey<Style> Default => new("PipsPagerStyle");
 			}
 
 			public static class ProgressBar
 			{
 				[ResourceKeyDefinition(typeof(Style), "ProgressBarStyle", TargetType = typeof(ProgressBar))]
-				public static ResourceValue<Style> Default => new("ProgressBarStyle");
+				public static StaticResourceKey<Style> Default => new("ProgressBarStyle");
 			}
 
 			public static class ProgressRing
 			{
 				[ResourceKeyDefinition(typeof(Style), "ProgressRingStyle", TargetType = typeof(ProgressRing))]
-				public static ResourceValue<Style> Default => new("ProgressRingStyle");
+				public static StaticResourceKey<Style> Default => new("ProgressRingStyle");
 			}
 
 			public static class Slider
 			{
 				[ResourceKeyDefinition(typeof(Style), "SliderStyle", TargetType = typeof(Slider))]
-				public static ResourceValue<Style> Default => new("SliderStyle");
+				public static StaticResourceKey<Style> Default => new("SliderStyle");
 			}
 
 			public static class TextBlock
 			{
 				[ResourceKeyDefinition(typeof(Style), "DisplayLarge", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> DisplayLarge => new("DisplayLarge");
+				public static StaticResourceKey<Style> DisplayLarge => new("DisplayLarge");
 
 				[ResourceKeyDefinition(typeof(Style), "DisplayMedium", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> DisplayMedium => new("DisplayMedium");
+				public static StaticResourceKey<Style> DisplayMedium => new("DisplayMedium");
 
 				[ResourceKeyDefinition(typeof(Style), "DisplaySmall", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> DisplaySmall => new("DisplaySmall");
+				public static StaticResourceKey<Style> DisplaySmall => new("DisplaySmall");
 
 				[ResourceKeyDefinition(typeof(Style), "HeadlineLarge", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> HeadlineLarge => new("HeadlineLarge");
+				public static StaticResourceKey<Style> HeadlineLarge => new("HeadlineLarge");
 
 				[ResourceKeyDefinition(typeof(Style), "HeadlineMedium", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> HeadlineMedium => new("HeadlineMedium");
+				public static StaticResourceKey<Style> HeadlineMedium => new("HeadlineMedium");
 
 				[ResourceKeyDefinition(typeof(Style), "HeadlineSmall", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> HeadlineSmall => new("HeadlineSmall");
+				public static StaticResourceKey<Style> HeadlineSmall => new("HeadlineSmall");
 
 				[ResourceKeyDefinition(typeof(Style), "TitleLarge", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> TitleLarge => new("TitleLarge");
+				public static StaticResourceKey<Style> TitleLarge => new("TitleLarge");
 
 				[ResourceKeyDefinition(typeof(Style), "TitleMedium", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> TitleMedium => new("TitleMedium");
+				public static StaticResourceKey<Style> TitleMedium => new("TitleMedium");
 
 				[ResourceKeyDefinition(typeof(Style), "TitleSmall", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> TitleSmall => new("TitleSmall");
+				public static StaticResourceKey<Style> TitleSmall => new("TitleSmall");
 
 				[ResourceKeyDefinition(typeof(Style), "LabelLarge", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> LabelLarge => new("LabelLarge");
+				public static StaticResourceKey<Style> LabelLarge => new("LabelLarge");
 
 				[ResourceKeyDefinition(typeof(Style), "LabelMedium", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> LabelMedium => new("LabelMedium");
+				public static StaticResourceKey<Style> LabelMedium => new("LabelMedium");
 
 				[ResourceKeyDefinition(typeof(Style), "LabelSmall", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> LabelSmall => new("LabelSmall");
+				public static StaticResourceKey<Style> LabelSmall => new("LabelSmall");
 
 				[ResourceKeyDefinition(typeof(Style), "LabelExtraSmall", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> LabelExtraSmall => new("LabelExtraSmall");
+				public static StaticResourceKey<Style> LabelExtraSmall => new("LabelExtraSmall");
 
 				[ResourceKeyDefinition(typeof(Style), "BodyLarge", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> BodyLarge => new("BodyLarge");
+				public static StaticResourceKey<Style> BodyLarge => new("BodyLarge");
 
 				[ResourceKeyDefinition(typeof(Style), "BodyMedium", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> BodyMedium => new("BodyMedium");
+				public static StaticResourceKey<Style> BodyMedium => new("BodyMedium");
 
 				[ResourceKeyDefinition(typeof(Style), "BodySmall", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> BodySmall => new("BodySmall");
+				public static StaticResourceKey<Style> BodySmall => new("BodySmall");
 
 				[ResourceKeyDefinition(typeof(Style), "CaptionLarge", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> CaptionLarge => new("CaptionLarge");
+				public static StaticResourceKey<Style> CaptionLarge => new("CaptionLarge");
 
 				[ResourceKeyDefinition(typeof(Style), "CaptionMedium", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> CaptionMedium => new("CaptionMedium");
+				public static StaticResourceKey<Style> CaptionMedium => new("CaptionMedium");
 
 				[ResourceKeyDefinition(typeof(Style), "CaptionSmall", TargetType = typeof(TextBlock))]
-				public static ResourceValue<Style> CaptionSmall => new("CaptionSmall");
+				public static StaticResourceKey<Style> CaptionSmall => new("CaptionSmall");
 			}
 
 			public static class TextBox
 			{
 				[ResourceKeyDefinition(typeof(Style), "FilledTextBoxStyle", TargetType = typeof(TextBox))]
-				public static ResourceValue<Style> Filled => new("FilledTextBoxStyle");
+				public static StaticResourceKey<Style> Filled => new("FilledTextBoxStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "OutlinedTextBoxStyle", TargetType = typeof(TextBox))]
-				public static ResourceValue<Style> Outlined => new("OutlinedTextBoxStyle");
+				public static StaticResourceKey<Style> Outlined => new("OutlinedTextBoxStyle");
 			}
 
 			public static class ToggleButton
 			{
 				[ResourceKeyDefinition(typeof(Style), "TextToggleButtonStyle", TargetType = typeof(ToggleButton))]
-				public static ResourceValue<Style> Text => new("TextToggleButtonStyle");
+				public static StaticResourceKey<Style> Text => new("TextToggleButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "IconToggleButtonStyle", TargetType = typeof(ToggleButton))]
-				public static ResourceValue<Style> Icon => new("IconToggleButtonStyle");
+				public static StaticResourceKey<Style> Icon => new("IconToggleButtonStyle");
 			}
 
 			public static class ToggleSwitch
 			{
 				[ResourceKeyDefinition(typeof(Style), "ToggleSwitchStyle", TargetType = typeof(ToggleSwitch))]
-				public static ResourceValue<Style> Default => new("ToggleSwitchStyle");
+				public static StaticResourceKey<Style> Default => new("ToggleSwitchStyle");
 			}
 		}
 	}

From ec4a45b3f32a95fefd3585c7dbe981cebe1a51de Mon Sep 17 00:00:00 2001
From: Dan Siegel <me@dansiegel.net>
Date: Wed, 20 Sep 2023 07:25:09 -0600
Subject: [PATCH 3/5] chore: adding missing namespace

---
 src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs | 1 +
 src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs  | 3 ++-
 src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs  | 1 +
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs b/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs
index 9d43f30a8..1e2614e39 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme.Brushes.cs
@@ -1,4 +1,5 @@
 using Microsoft.UI.Xaml.Media;
+using Uno.Extensions.Markup;
 using Uno.Extensions.Markup.Internals;
 
 namespace Uno.Themes.Markup
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs b/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs
index b6514a3c4..0ae370524 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme.Colors.cs
@@ -1,4 +1,5 @@
-using Uno.Extensions.Markup.Internals;
+using Uno.Extensions.Markup;
+using Uno.Extensions.Markup.Internals;
 using Windows.UI;
 
 namespace Uno.Themes.Markup
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs b/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs
index a3f105a81..f3c65decd 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme.Styles.cs
@@ -1,4 +1,5 @@
 using Microsoft.UI.Xaml;
+using Uno.Extensions.Markup;
 using Uno.Extensions.Markup.Internals;
 
 namespace Uno.Themes.Markup

From c369e2b79545e0e96a8452fc3791ddd99603a796 Mon Sep 17 00:00:00 2001
From: Dan Siegel <me@dansiegel.net>
Date: Mon, 25 Sep 2023 07:23:42 -0600
Subject: [PATCH 4/5] chore: update Markup libs

---
 .../Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj  | 2 +-
 .../Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj b/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj
index 88dc98ed5..0507deb9e 100644
--- a/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj
+++ b/src/library/Uno.Material.WinUI.Markup/Uno.Material.WinUI.Markup.csproj
@@ -19,7 +19,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Uno.Extensions.Markup.Generators" PrivateAssets="All" Version="5.0.0-dev.394" />
+		<PackageReference Include="Uno.Extensions.Markup.Generators" PrivateAssets="All" Version="5.0.0-dev.407" />
 	</ItemGroup>
 
 	<PropertyGroup>
diff --git a/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj b/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj
index f4b125f7e..ae878b7ba 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj
+++ b/src/library/Uno.Themes.WinUI.Markup/Uno.Themes.WinUI.Markup.csproj
@@ -14,7 +14,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Uno.WinUI.Markup" Version="5.0.0-dev.394" />
+		<PackageReference Include="Uno.WinUI.Markup" Version="5.0.0-dev.407" />
 	</ItemGroup>
 
 	<PropertyGroup>

From 330eb76b3dcbdf995b9010dc90adbfa19cd564bb Mon Sep 17 00:00:00 2001
From: Dan Siegel <me@dansiegel.net>
Date: Tue, 26 Sep 2023 07:00:14 -0600
Subject: [PATCH 5/5] chore: updating to resource key's

---
 .../Uno.Themes.WinUI.Markup/Theme/Button.cs   | 287 +++++++++---------
 .../Uno.Themes.WinUI.Markup/Theme/ComboBox.cs | 143 ++++-----
 .../Theme/PasswordBox.cs                      |  91 +++---
 .../Theme/RadioButton.cs                      |  57 ++--
 4 files changed, 291 insertions(+), 287 deletions(-)

diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme/Button.cs b/src/library/Uno.Themes.WinUI.Markup/Theme/Button.cs
index 6d4c13e7a..a597ef2f5 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme/Button.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme/Button.cs
@@ -1,5 +1,6 @@
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
+using Uno.Extensions.Markup;
 using Uno.Extensions.Markup.Internals;
 
 namespace Uno.Themes.Markup
@@ -15,85 +16,85 @@ public static class Elevated
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonForeground")]
-						public static ResourceValue<Brush> Default => new("ElevatedButtonForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ElevatedButtonForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ElevatedButtonForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ElevatedButtonForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ElevatedButtonForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ElevatedButtonForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ElevatedButtonForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ElevatedButtonForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("ElevatedButtonForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("ElevatedButtonForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ElevatedButtonForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ElevatedButtonForegroundDisabled");
 					}
 
 					public static class IconForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonIconForeground")]
-						public static ResourceValue<Brush> Default => new("ElevatedButtonIconForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ElevatedButtonIconForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonIconForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ElevatedButtonIconForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ElevatedButtonIconForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonIconForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ElevatedButtonIconForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ElevatedButtonIconForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonIconForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ElevatedButtonIconForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ElevatedButtonIconForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonIconForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("ElevatedButtonIconForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("ElevatedButtonIconForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonIconForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ElevatedButtonIconForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ElevatedButtonIconForegroundDisabled");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBackground")]
-						public static ResourceValue<Brush> Default => new("ElevatedButtonBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("ElevatedButtonBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ElevatedButtonBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ElevatedButtonBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ElevatedButtonBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ElevatedButtonBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ElevatedButtonBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ElevatedButtonBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBackgroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("ElevatedButtonBackgroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("ElevatedButtonBackgroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ElevatedButtonBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ElevatedButtonBackgroundDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBorderBrush")]
-						public static ResourceValue<Brush> Default => new("ElevatedButtonBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("ElevatedButtonBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ElevatedButtonBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ElevatedButtonBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBorderBrushPressed")]
-						public static ResourceValue<Brush> Pressed => new("ElevatedButtonBorderBrushPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ElevatedButtonBorderBrushPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBorderBrushFocused")]
-						public static ResourceValue<Brush> Focused => new("ElevatedButtonBorderBrushFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ElevatedButtonBorderBrushFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBorderBrushPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("ElevatedButtonBorderBrushPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("ElevatedButtonBorderBrushPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ElevatedButtonBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ElevatedButtonBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ElevatedButtonBorderBrushDisabled");
 					}
 				}
 
@@ -102,85 +103,85 @@ public static class Filled
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonForeground")]
-						public static ResourceValue<Brush> Default => new("FilledButtonForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledButtonForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledButtonForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledButtonForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledButtonForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledButtonForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledButtonForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledButtonForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledButtonForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledButtonForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledButtonForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledButtonForegroundDisabled");
 					}
 
 					public static class IconForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonIconForeground")]
-						public static ResourceValue<Brush> Default => new("FilledButtonIconForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledButtonIconForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonIconForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledButtonIconForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledButtonIconForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonIconForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledButtonIconForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledButtonIconForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonIconForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledButtonIconForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledButtonIconForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonIconForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledButtonIconForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledButtonIconForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonIconForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledButtonIconForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledButtonIconForegroundDisabled");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBackground")]
-						public static ResourceValue<Brush> Default => new("FilledButtonBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledButtonBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledButtonBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledButtonBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledButtonBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledButtonBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledButtonBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledButtonBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBackgroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledButtonBackgroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledButtonBackgroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledButtonBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledButtonBackgroundDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBorderBrush")]
-						public static ResourceValue<Brush> Default => new("FilledButtonBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledButtonBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledButtonBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledButtonBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBorderBrushPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledButtonBorderBrushPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledButtonBorderBrushPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBorderBrushFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledButtonBorderBrushFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledButtonBorderBrushFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBorderBrushPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledButtonBorderBrushPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledButtonBorderBrushPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledButtonBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledButtonBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledButtonBorderBrushDisabled");
 					}
 				}
 
@@ -189,85 +190,85 @@ public static class FilledTonal
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonForeground")]
-						public static ResourceValue<Brush> Default => new("FilledTonalButtonForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledTonalButtonForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledTonalButtonForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledTonalButtonForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledTonalButtonForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledTonalButtonForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledTonalButtonForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledTonalButtonForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledTonalButtonForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledTonalButtonForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledTonalButtonForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledTonalButtonForegroundDisabled");
 					}
 
 					public static class IconForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonIconForeground")]
-						public static ResourceValue<Brush> Default => new("FilledTonalButtonIconForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledTonalButtonIconForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonIconForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledTonalButtonIconForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledTonalButtonIconForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonIconForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledTonalButtonIconForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledTonalButtonIconForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonIconForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledTonalButtonIconForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledTonalButtonIconForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonIconForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledTonalButtonIconForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledTonalButtonIconForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonIconForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledTonalButtonIconForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledTonalButtonIconForegroundDisabled");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBackground")]
-						public static ResourceValue<Brush> Default => new("FilledTonalButtonBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledTonalButtonBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledTonalButtonBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledTonalButtonBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledTonalButtonBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledTonalButtonBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledTonalButtonBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledTonalButtonBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBackgroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledTonalButtonBackgroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledTonalButtonBackgroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledTonalButtonBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledTonalButtonBackgroundDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBorderBrush")]
-						public static ResourceValue<Brush> Default => new("FilledTonalButtonBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledTonalButtonBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledTonalButtonBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledTonalButtonBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBorderBrushPressed")]
-						public static ResourceValue<Brush> Pressed => new("FilledTonalButtonBorderBrushPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("FilledTonalButtonBorderBrushPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBorderBrushFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledTonalButtonBorderBrushFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledTonalButtonBorderBrushFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBorderBrushPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("FilledTonalButtonBorderBrushPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("FilledTonalButtonBorderBrushPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledTonalButtonBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledTonalButtonBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledTonalButtonBorderBrushDisabled");
 					}
 				}
 
@@ -276,85 +277,85 @@ public static class Outlined
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonForeground")]
-						public static ResourceValue<Brush> Default => new("OutlinedButtonForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("OutlinedButtonForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("OutlinedButtonForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("OutlinedButtonForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("OutlinedButtonForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("OutlinedButtonForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("OutlinedButtonForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("OutlinedButtonForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("OutlinedButtonForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("OutlinedButtonForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("OutlinedButtonForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("OutlinedButtonForegroundDisabled");
 					}
 
 					public static class IconForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonIconForeground")]
-						public static ResourceValue<Brush> Default => new("OutlinedButtonIconForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("OutlinedButtonIconForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonIconForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("OutlinedButtonIconForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("OutlinedButtonIconForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonIconForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("OutlinedButtonIconForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("OutlinedButtonIconForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonIconForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("OutlinedButtonIconForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("OutlinedButtonIconForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonIconForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("OutlinedButtonIconForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("OutlinedButtonIconForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonIconForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("OutlinedButtonIconForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("OutlinedButtonIconForegroundDisabled");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBackground")]
-						public static ResourceValue<Brush> Default => new("OutlinedButtonBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("OutlinedButtonBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("OutlinedButtonBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("OutlinedButtonBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("OutlinedButtonBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("OutlinedButtonBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("OutlinedButtonBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("OutlinedButtonBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBackgroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("OutlinedButtonBackgroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("OutlinedButtonBackgroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("OutlinedButtonBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("OutlinedButtonBackgroundDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBorderBrush")]
-						public static ResourceValue<Brush> Default => new("OutlinedButtonBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("OutlinedButtonBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("OutlinedButtonBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("OutlinedButtonBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBorderBrushPressed")]
-						public static ResourceValue<Brush> Pressed => new("OutlinedButtonBorderBrushPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("OutlinedButtonBorderBrushPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBorderBrushFocused")]
-						public static ResourceValue<Brush> Focused => new("OutlinedButtonBorderBrushFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("OutlinedButtonBorderBrushFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBorderBrushPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("OutlinedButtonBorderBrushPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("OutlinedButtonBorderBrushPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedButtonBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("OutlinedButtonBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("OutlinedButtonBorderBrushDisabled");
 					}
 				}
 
@@ -363,85 +364,85 @@ public static class Text
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonForeground")]
-						public static ResourceValue<Brush> Default => new("TextButtonForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("TextButtonForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("TextButtonForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("TextButtonForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("TextButtonForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("TextButtonForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("TextButtonForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("TextButtonForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("TextButtonForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("TextButtonForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("TextButtonForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("TextButtonForegroundDisabled");
 					}
 
 					public static class IconForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonIconForeground")]
-						public static ResourceValue<Brush> Default => new("TextButtonIconForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("TextButtonIconForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonIconForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("TextButtonIconForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("TextButtonIconForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonIconForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("TextButtonIconForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("TextButtonIconForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonIconForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("TextButtonIconForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("TextButtonIconForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonIconForegroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("TextButtonIconForegroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("TextButtonIconForegroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonIconForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("TextButtonIconForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("TextButtonIconForegroundDisabled");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBackground")]
-						public static ResourceValue<Brush> Default => new("TextButtonBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("TextButtonBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("TextButtonBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("TextButtonBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("TextButtonBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("TextButtonBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("TextButtonBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("TextButtonBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBackgroundPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("TextButtonBackgroundPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("TextButtonBackgroundPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("TextButtonBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("TextButtonBackgroundDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBorderBrush")]
-						public static ResourceValue<Brush> Default => new("TextButtonBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("TextButtonBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("TextButtonBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("TextButtonBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBorderBrushPressed")]
-						public static ResourceValue<Brush> Pressed => new("TextButtonBorderBrushPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("TextButtonBorderBrushPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBorderBrushFocused")]
-						public static ResourceValue<Brush> Focused => new("TextButtonBorderBrushFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("TextButtonBorderBrushFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBorderBrushPointerFocused")]
-						public static ResourceValue<Brush> PointerFocused => new("TextButtonBorderBrushPointerFocused", true);
+						public static ThemeResourceKey<Brush> PointerFocused => new("TextButtonBorderBrushPointerFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "TextButtonBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("TextButtonBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("TextButtonBorderBrushDisabled");
 					}
 				}
 
@@ -450,22 +451,22 @@ public static class Icon
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "IconButtonForeground")]
-						public static ResourceValue<Brush> Default => new("IconButtonForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("IconButtonForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "IconButtonForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("IconButtonForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("IconButtonForegroundDisabled");
 					}
 
 					public static class EllipseFill
 					{
 						[ResourceKeyDefinition(typeof(Brush), "IconButtonEllipseFillPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("IconButtonEllipseFillPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("IconButtonEllipseFillPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "IconButtonEllipseFillPressed")]
-						public static ResourceValue<Brush> Pressed => new("IconButtonEllipseFillPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("IconButtonEllipseFillPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "IconButtonEllipseFillFocused")]
-						public static ResourceValue<Brush> Focused => new("IconButtonEllipseFillFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("IconButtonEllipseFillFocused");
 					}
 				}
 			}
@@ -473,58 +474,58 @@ public static class EllipseFill
 			public static class Styles
 			{
 				[ResourceKeyDefinition(typeof(Style), "ElevatedButtonStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> Elevated => new("ElevatedButtonStyle");
+				public static StaticResourceKey<Style> Elevated => new("ElevatedButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "FilledButtonStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> Filled => new("FilledButtonStyle");
+				public static StaticResourceKey<Style> Filled => new("FilledButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "FilledTonalButtonStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> FilledTonal => new("FilledTonalButtonStyle");
+				public static StaticResourceKey<Style> FilledTonal => new("FilledTonalButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "OutlinedButtonStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> Outlined => new("OutlinedButtonStyle");
+				public static StaticResourceKey<Style> Outlined => new("OutlinedButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "TextButtonStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> Text => new("TextButtonStyle");
+				public static StaticResourceKey<Style> Text => new("TextButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "IconButtonStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> Icon => new("IconButtonStyle");
+				public static StaticResourceKey<Style> Icon => new("IconButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "FabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> Fab => new("FabStyle");
+				public static StaticResourceKey<Style> Fab => new("FabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SurfaceFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> SurfaceFab => new("SurfaceFabStyle");
+				public static StaticResourceKey<Style> SurfaceFab => new("SurfaceFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SecondaryFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> SecondaryFab => new("SecondaryFabStyle");
+				public static StaticResourceKey<Style> SecondaryFab => new("SecondaryFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "TertiaryFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> TertiaryFab => new("TertiaryFabStyle");
+				public static StaticResourceKey<Style> TertiaryFab => new("TertiaryFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SmallFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> SmallFab => new("SmallFabStyle");
+				public static StaticResourceKey<Style> SmallFab => new("SmallFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SurfaceSmallFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> SurfaceSmallFab => new("SurfaceSmallFabStyle");
+				public static StaticResourceKey<Style> SurfaceSmallFab => new("SurfaceSmallFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SecondarySmallFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> SecondarySmallFab => new("SecondarySmallFabStyle");
+				public static StaticResourceKey<Style> SecondarySmallFab => new("SecondarySmallFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "TertiarySmallFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> TertiarySmallFab => new("TertiarySmallFabStyle");
+				public static StaticResourceKey<Style> TertiarySmallFab => new("TertiarySmallFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "LargeFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> LargeFab => new("LargeFabStyle");
+				public static StaticResourceKey<Style> LargeFab => new("LargeFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SurfaceLargeFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> SurfaceLargeFab => new("SurfaceLargeFabStyle");
+				public static StaticResourceKey<Style> SurfaceLargeFab => new("SurfaceLargeFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SecondaryLargeFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> SecondaryLargeFab => new("SecondaryLargeFabStyle");
+				public static StaticResourceKey<Style> SecondaryLargeFab => new("SecondaryLargeFabStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "TertiaryLargeFabStyle", TargetType = typeof(Button))]
-				public static ResourceValue<Style> TertiaryLargeFab => new("TertiaryLargeFabStyle");
+				public static StaticResourceKey<Style> TertiaryLargeFab => new("TertiaryLargeFabStyle");
 			}
 		}
 	}
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme/ComboBox.cs b/src/library/Uno.Themes.WinUI.Markup/Theme/ComboBox.cs
index c60bc2227..4a4c39dd6 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme/ComboBox.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme/ComboBox.cs
@@ -1,5 +1,6 @@
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
+using Uno.Extensions.Markup;
 using Uno.Extensions.Markup.Internals;
 
 namespace Uno.Themes.Markup
@@ -15,109 +16,109 @@ public static class Default
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxForegroundDisabled");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ComboBoxForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ComboBoxForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxForegroundFocusedPressed")]
-						public static ResourceValue<Brush> FocusedPressed => new("ComboBoxForegroundFocusedPressed", true);
+						public static ThemeResourceKey<Brush> FocusedPressed => new("ComboBoxForegroundFocusedPressed");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBackground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxBackgroundDisabled");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBackgroundUnfocused")]
-						public static ResourceValue<Brush> Unfocused => new("ComboBoxBackgroundUnfocused", true);
+						public static ThemeResourceKey<Brush> Unfocused => new("ComboBoxBackgroundUnfocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ComboBoxBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ComboBoxBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBackgroundFocusedPressed")]
-						public static ResourceValue<Brush> FocusedPressed => new("ComboBoxBackgroundFocusedPressed", true);
+						public static ThemeResourceKey<Brush> FocusedPressed => new("ComboBoxBackgroundFocusedPressed");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBorderBrush")]
-						public static ResourceValue<Brush> Default => new("ComboBoxBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBorderBrushPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxBorderBrushPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxBorderBrushPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxBorderBrushDisabled");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxBorderBrushOpened")]
-						public static ResourceValue<Brush> Opened => new("ComboBoxBorderBrushOpened", true);
+						public static ThemeResourceKey<Brush> Opened => new("ComboBoxBorderBrushOpened");
 					}
 
 					public static class PlaceHolderForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxPlaceHolderForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxPlaceHolderForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxPlaceHolderForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxPlaceHolderForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxPlaceHolderForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxPlaceHolderForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxPlaceHolderForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxPlaceHolderForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxPlaceHolderForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxPlaceHolderForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxPlaceHolderForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxPlaceHolderForegroundDisabled");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxPlaceHolderForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ComboBoxPlaceHolderForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ComboBoxPlaceHolderForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxPlaceHolderForegroundFocusedPressed")]
-						public static ResourceValue<Brush> FocusedPressed => new("ComboBoxPlaceHolderForegroundFocusedPressed", true);
+						public static ThemeResourceKey<Brush> FocusedPressed => new("ComboBoxPlaceHolderForegroundFocusedPressed");
 					}
 
 					public static class LeadingIconForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxLeadingIconForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxLeadingIconForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxLeadingIconForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxLeadingIconForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxLeadingIconForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxLeadingIconForegroundDisabled");
 					}
 
 					public static class ArrowForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxArrowForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxArrowForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxArrowForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxArrowForegroundOpened")]
-						public static ResourceValue<Brush> Opened => new("ComboBoxArrowForegroundOpened", true);
+						public static ThemeResourceKey<Brush> Opened => new("ComboBoxArrowForegroundOpened");
 					}
 
 					public static class UpperPlaceHolderForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxUpperPlaceHolderForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxUpperPlaceHolderForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxUpperPlaceHolderForeground");
 					}
 				}
 
@@ -126,106 +127,106 @@ public static class ComboBoxItem
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxItemForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxItemForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxItemForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxItemForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxItemForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxItemForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxItemForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxItemForegroundDisabled");
 					}
 
 					public static class ForegroundSelected
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundSelected")]
-						public static ResourceValue<Brush> Default => new("ComboBoxItemForegroundSelected", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxItemForegroundSelected");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundSelectedUnfocused")]
-						public static ResourceValue<Brush> Unfocused => new("ComboBoxItemForegroundSelectedUnfocused", true);
+						public static ThemeResourceKey<Brush> Unfocused => new("ComboBoxItemForegroundSelectedUnfocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundSelectedPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxItemForegroundSelectedPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxItemForegroundSelectedPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundSelectedPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxItemForegroundSelectedPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxItemForegroundSelectedPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemForegroundSelectedDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxItemForegroundSelectedDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxItemForegroundSelectedDisabled");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxItemBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxItemBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxItemBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxItemBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxItemBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxItemBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxItemBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxItemBackgroundDisabled");
 					}
 
 					public static class BackgroundSelected
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundSelected")]
-						public static ResourceValue<Brush> Default => new("ComboBoxItemBackgroundSelected", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxItemBackgroundSelected");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundSelectedUnfocused")]
-						public static ResourceValue<Brush> Unfocused => new("ComboBoxItemBackgroundSelectedUnfocused", true);
+						public static ThemeResourceKey<Brush> Unfocused => new("ComboBoxItemBackgroundSelectedUnfocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundSelectedPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxItemBackgroundSelectedPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxItemBackgroundSelectedPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundSelectedPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxItemBackgroundSelectedPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxItemBackgroundSelectedPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBackgroundSelectedDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxItemBackgroundSelectedDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxItemBackgroundSelectedDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrush")]
-						public static ResourceValue<Brush> Default => new("ComboBoxItemBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxItemBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxItemBorderBrushPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxItemBorderBrushPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxItemBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxItemBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxItemBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxItemBorderBrushDisabled");
 					}
 
 					public static class BorderBrushSelected
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushSelected")]
-						public static ResourceValue<Brush> Default => new("ComboBoxItemBorderBrushSelected", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxItemBorderBrushSelected");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushSelectedUnfocused")]
-						public static ResourceValue<Brush> Unfocused => new("ComboBoxItemBorderBrushSelectedUnfocused", true);
+						public static ThemeResourceKey<Brush> Unfocused => new("ComboBoxItemBorderBrushSelectedUnfocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushSelectedPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxItemBorderBrushSelectedPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxItemBorderBrushSelectedPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushSelectedPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxItemBorderBrushSelectedPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxItemBorderBrushSelectedPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemBorderBrushSelectedDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxItemBorderBrushSelectedDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxItemBorderBrushSelectedDisabled");
 					}
 
 					public static class PillFill
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxItemPillFillBrush")]
-						public static ResourceValue<Brush> Default => new("ComboBoxItemPillFillBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxItemPillFillBrush");
 					}
 				}
 
@@ -234,49 +235,49 @@ public static class DropDown
 					public static class GlyphForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownGlyphForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxDropDownGlyphForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxDropDownGlyphForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownGlyphForegroundFocusedPressed")]
-						public static ResourceValue<Brush> FocusedPressed => new("ComboBoxDropDownGlyphForegroundFocusedPressed", true);
+						public static ThemeResourceKey<Brush> FocusedPressed => new("ComboBoxDropDownGlyphForegroundFocusedPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownGlyphForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ComboBoxDropDownGlyphForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ComboBoxDropDownGlyphForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownGlyphForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("ComboBoxDropDownGlyphForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("ComboBoxDropDownGlyphForegroundDisabled");
 					}
 
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxDropDownForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxDropDownForeground");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownBorderBrush")]
-						public static ResourceValue<Brush> Default => new("ComboBoxDropDownBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxDropDownBorderBrush");
 					}
 
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownBackground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxDropDownBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxDropDownBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("ComboBoxDropDownBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("ComboBoxDropDownBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownBackgroundPointerPressed")]
-						public static ResourceValue<Brush> PointerPressed => new("ComboBoxDropDownBackgroundPointerPressed", true);
+						public static ThemeResourceKey<Brush> PointerPressed => new("ComboBoxDropDownBackgroundPointerPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownBackgroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("ComboBoxDropDownBackgroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("ComboBoxDropDownBackgroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("ComboBoxDropDownBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("ComboBoxDropDownBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxDropDownBackgroundFocusedPressed")]
-						public static ResourceValue<Brush> FocusedPressed => new("ComboBoxDropDownBackgroundFocusedPressed", true);
+						public static ThemeResourceKey<Brush> FocusedPressed => new("ComboBoxDropDownBackgroundFocusedPressed");
 					}
 				}
 
@@ -285,7 +286,7 @@ public static class EditableDropDown
 					public static class GlyphForeground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "ComboBoxEditableDropDownGlyphForeground")]
-						public static ResourceValue<Brush> Default => new("ComboBoxEditableDropDownGlyphForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("ComboBoxEditableDropDownGlyphForeground");
 					}
 				}
 			}
@@ -293,7 +294,7 @@ public static class GlyphForeground
 			public static class Styles
 			{
 				[ResourceKeyDefinition(typeof(Style), "ComboBoxStyle", TargetType = typeof(ComboBox))]
-				public static ResourceValue<Style> Default => new("ComboBoxStyle");
+				public static StaticResourceKey<Style> Default => new("ComboBoxStyle");
 			}
 		}
 	}
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme/PasswordBox.cs b/src/library/Uno.Themes.WinUI.Markup/Theme/PasswordBox.cs
index 3144b7b1c..9c9457852 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme/PasswordBox.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme/PasswordBox.cs
@@ -1,6 +1,7 @@
 using Microsoft.UI.Text;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
+using Uno.Extensions.Markup;
 using Uno.Extensions.Markup.Internals;
 
 namespace Uno.Themes.Markup
@@ -20,7 +21,7 @@ public static class Glyph
 							public static class PathData
 							{
 								[ResourceKeyDefinition(typeof(Geometry), "PasswordBoxRevealGlyphPathData")]
-								public static ResourceValue<Geometry> Default => new("PasswordBoxRevealGlyphPathData", true);
+								public static ThemeResourceKey<Geometry> Default => new("PasswordBoxRevealGlyphPathData");
 							}
 						}
 
@@ -29,7 +30,7 @@ public static class Button
 							public static class Foreground
 							{
 								[ResourceKeyDefinition(typeof(Brush), "PasswordBoxRevealButtonForeground")]
-								public static ResourceValue<Brush> Default => new("PasswordBoxRevealButtonForeground", true);
+								public static ThemeResourceKey<Brush> Default => new("PasswordBoxRevealButtonForeground");
 							}
 						}
 					}
@@ -40,46 +41,46 @@ public static class Filled
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBackground")]
-						public static ResourceValue<Brush> Default => new("FilledPasswordBoxBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledPasswordBoxBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledPasswordBoxBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledPasswordBoxBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledPasswordBoxBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledPasswordBoxBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledPasswordBoxBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledPasswordBoxBackgroundDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBorderBrush")]
-						public static ResourceValue<Brush> Default => new("FilledPasswordBoxBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledPasswordBoxBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledPasswordBoxBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledPasswordBoxBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBorderBrushFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledPasswordBoxBorderBrushFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledPasswordBoxBorderBrushFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledPasswordBoxBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledPasswordBoxBorderBrushDisabled");
 					}
 
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxForeground")]
-						public static ResourceValue<Brush> Default => new("FilledPasswordBoxForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("FilledPasswordBoxForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("FilledPasswordBoxForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("FilledPasswordBoxForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("FilledPasswordBoxForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("FilledPasswordBoxForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("FilledPasswordBoxForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("FilledPasswordBoxForegroundDisabled");
 					}
 
 					public static class Placeholder
@@ -87,16 +88,16 @@ public static class Placeholder
 						public static class Foreground
 						{
 							[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxPlaceholderForeground")]
-							public static ResourceValue<Brush> Default => new("FilledPasswordBoxPlaceholderForeground", true);
+							public static ThemeResourceKey<Brush> Default => new("FilledPasswordBoxPlaceholderForeground");
 
 							[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxPlaceholderForegroundPointerOver")]
-							public static ResourceValue<Brush> PointerOver => new("FilledPasswordBoxPlaceholderForegroundPointerOver", true);
+							public static ThemeResourceKey<Brush> PointerOver => new("FilledPasswordBoxPlaceholderForegroundPointerOver");
 
 							[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxPlaceholderForegroundFocused")]
-							public static ResourceValue<Brush> Focused => new("FilledPasswordBoxPlaceholderForegroundFocused", true);
+							public static ThemeResourceKey<Brush> Focused => new("FilledPasswordBoxPlaceholderForegroundFocused");
 
 							[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxPlaceholderForegroundDisabled")]
-							public static ResourceValue<Brush> Disabled => new("FilledPasswordBoxPlaceholderForegroundDisabled", true);
+							public static ThemeResourceKey<Brush> Disabled => new("FilledPasswordBoxPlaceholderForegroundDisabled");
 						}
 					}
 
@@ -105,23 +106,23 @@ public static class RevealButton
 						public static class Foreground
 						{
 							[ResourceKeyDefinition(typeof(Brush), "FilledPasswordBoxRevealButtonForeground")]
-							public static ResourceValue<Brush> Default => new("FilledPasswordBoxRevealButtonForeground", true);
+							public static ThemeResourceKey<Brush> Default => new("FilledPasswordBoxRevealButtonForeground");
 						}
 					}
 
 					public static class Typography
 					{
 						[ResourceKeyDefinition(typeof(FontFamily), "FilledPasswordBoxFontFamily")]
-						public static ResourceValue<FontFamily> FontFamily => new("FilledPasswordBoxFontFamily", true);
+						public static StaticResourceKey<FontFamily> FontFamily => new("FilledPasswordBoxFontFamily");
 
 						[ResourceKeyDefinition(typeof(FontWeights), "FilledPasswordBoxFontWeight")]
-						public static ResourceValue<FontWeights> FontWeight => new("FilledPasswordBoxFontWeight", true);
+						public static StaticResourceKey<FontWeights> FontWeight => new("FilledPasswordBoxFontWeight");
 
 						[ResourceKeyDefinition(typeof(double), "FilledPasswordBoxFontSize")]
-						public static ResourceValue<double> FontSize => new("FilledPasswordBoxFontSize", true);
+						public static StaticResourceKey<double> FontSize => new("FilledPasswordBoxFontSize");
 
 						[ResourceKeyDefinition(typeof(int), "FilledPasswordBoxCharacterSpacing")]
-						public static ResourceValue<int> CharacterSpacing => new("FilledPasswordBoxCharacterSpacing", true);
+						public static StaticResourceKey<int> CharacterSpacing => new("FilledPasswordBoxCharacterSpacing");
 					}
 				}
 
@@ -130,46 +131,46 @@ public static class Outlined
 					public static class Background
 					{
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBackground")]
-						public static ResourceValue<Brush> Default => new("OutlinedPasswordBoxBackground", true);
+						public static ThemeResourceKey<Brush> Default => new("OutlinedPasswordBoxBackground");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBackgroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("OutlinedPasswordBoxBackgroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("OutlinedPasswordBoxBackgroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBackgroundFocused")]
-						public static ResourceValue<Brush> Focused => new("OutlinedPasswordBoxBackgroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("OutlinedPasswordBoxBackgroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBackgroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("OutlinedPasswordBoxBackgroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("OutlinedPasswordBoxBackgroundDisabled");
 					}
 
 					public static class BorderBrush
 					{
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBorderBrush")]
-						public static ResourceValue<Brush> Default => new("OutlinedPasswordBoxBorderBrush", true);
+						public static ThemeResourceKey<Brush> Default => new("OutlinedPasswordBoxBorderBrush");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBorderBrushPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("OutlinedPasswordBoxBorderBrushPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("OutlinedPasswordBoxBorderBrushPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBorderBrushFocused")]
-						public static ResourceValue<Brush> Focused => new("OutlinedPasswordBoxBorderBrushFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("OutlinedPasswordBoxBorderBrushFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxBorderBrushDisabled")]
-						public static ResourceValue<Brush> Disabled => new("OutlinedPasswordBoxBorderBrushDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("OutlinedPasswordBoxBorderBrushDisabled");
 					}
 
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxForeground")]
-						public static ResourceValue<Brush> Default => new("OutlinedPasswordBoxForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("OutlinedPasswordBoxForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("OutlinedPasswordBoxForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("OutlinedPasswordBoxForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxForegroundFocused")]
-						public static ResourceValue<Brush> Focused => new("OutlinedPasswordBoxForegroundFocused", true);
+						public static ThemeResourceKey<Brush> Focused => new("OutlinedPasswordBoxForegroundFocused");
 
 						[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("OutlinedPasswordBoxForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("OutlinedPasswordBoxForegroundDisabled");
 					}
 
 					public static class Placeholder
@@ -177,32 +178,32 @@ public static class Placeholder
 						public static class Foreground
 						{
 							[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxPlaceholderForeground")]
-							public static ResourceValue<Brush> Default => new("OutlinedPasswordBoxPlaceholderForeground", true);
+							public static ThemeResourceKey<Brush> Default => new("OutlinedPasswordBoxPlaceholderForeground");
 
 							[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxPlaceholderForegroundPointerOver")]
-							public static ResourceValue<Brush> PointerOver => new("OutlinedPasswordBoxPlaceholderForegroundPointerOver", true);
+							public static ThemeResourceKey<Brush> PointerOver => new("OutlinedPasswordBoxPlaceholderForegroundPointerOver");
 
 							[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxPlaceholderForegroundFocused")]
-							public static ResourceValue<Brush> Focused => new("OutlinedPasswordBoxPlaceholderForegroundFocused", true);
+							public static ThemeResourceKey<Brush> Focused => new("OutlinedPasswordBoxPlaceholderForegroundFocused");
 
 							[ResourceKeyDefinition(typeof(Brush), "OutlinedPasswordBoxPlaceholderForegroundDisabled")]
-							public static ResourceValue<Brush> Disabled => new("OutlinedPasswordBoxPlaceholderForegroundDisabled", true);
+							public static ThemeResourceKey<Brush> Disabled => new("OutlinedPasswordBoxPlaceholderForegroundDisabled");
 						}
 					}
 
 					public static class Typography
 					{
 						[ResourceKeyDefinition(typeof(FontFamily), "OutlinedPasswordBoxFontFamily")]
-						public static ResourceValue<FontFamily> FontFamily => new("OutlinedPasswordBoxFontFamily", true);
+						public static StaticResourceKey<FontFamily> FontFamily => new("OutlinedPasswordBoxFontFamily");
 
 						[ResourceKeyDefinition(typeof(FontWeights), "OutlinedPasswordBoxFontWeight")]
-						public static ResourceValue<FontWeights> FontWeight => new("OutlinedPasswordBoxFontWeight", true);
+						public static StaticResourceKey<FontWeights> FontWeight => new("OutlinedPasswordBoxFontWeight");
 
 						[ResourceKeyDefinition(typeof(double), "OutlinedPasswordBoxFontSize")]
-						public static ResourceValue<double> FontSize => new("OutlinedPasswordBoxFontSize", true);
+						public static StaticResourceKey<double> FontSize => new("OutlinedPasswordBoxFontSize");
 
 						[ResourceKeyDefinition(typeof(int), "OutlinedPasswordBoxCharacterSpacing")]
-						public static ResourceValue<int> CharacterSpacing => new("OutlinedPasswordBoxCharacterSpacing", true);
+						public static StaticResourceKey<int> CharacterSpacing => new("OutlinedPasswordBoxCharacterSpacing");
 					}
 				}
 			}
@@ -210,10 +211,10 @@ public static class Typography
 			public static class Styles
 			{
 				[ResourceKeyDefinition(typeof(Style), "FilledPasswordBoxStyle", TargetType = typeof(PasswordBox))]
-				public static ResourceValue<Style> Filled => new("FilledPasswordBoxStyle");
+				public static StaticResourceKey<Style> Filled => new("FilledPasswordBoxStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "OutlinedPasswordBoxStyle", TargetType = typeof(PasswordBox))]
-				public static ResourceValue<Style> Outlined => new("OutlinedPasswordBoxStyle");
+				public static StaticResourceKey<Style> Outlined => new("OutlinedPasswordBoxStyle");
 			}
 		}
 	}
diff --git a/src/library/Uno.Themes.WinUI.Markup/Theme/RadioButton.cs b/src/library/Uno.Themes.WinUI.Markup/Theme/RadioButton.cs
index cdff75a93..f509fe4ff 100644
--- a/src/library/Uno.Themes.WinUI.Markup/Theme/RadioButton.cs
+++ b/src/library/Uno.Themes.WinUI.Markup/Theme/RadioButton.cs
@@ -1,5 +1,6 @@
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
+using Uno.Extensions.Markup;
 using Uno.Extensions.Markup.Internals;
 using Microsoft.UI.Text;
 
@@ -16,94 +17,94 @@ public static class Default
 					public static class Foreground
 					{
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonForeground")]
-						public static ResourceValue<Brush> Default => new("RadioButtonForeground", true);
+						public static ThemeResourceKey<Brush> Default => new("RadioButtonForeground");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonForegroundPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("RadioButtonForegroundPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("RadioButtonForegroundPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonForegroundPressed")]
-						public static ResourceValue<Brush> Pressed => new("RadioButtonForegroundPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("RadioButtonForegroundPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonForegroundDisabled")]
-						public static ResourceValue<Brush> Disabled => new("RadioButtonForegroundDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("RadioButtonForegroundDisabled");
 					}
 
 					public static class Stroke
 					{
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseStroke")]
-						public static ResourceValue<Brush> Default => new("RadioButtonOuterEllipseStroke", true);
+						public static ThemeResourceKey<Brush> Default => new("RadioButtonOuterEllipseStroke");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseStrokePointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("RadioButtonOuterEllipseStrokePointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("RadioButtonOuterEllipseStrokePointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseStrokePressed")]
-						public static ResourceValue<Brush> Pressed => new("RadioButtonOuterEllipseStrokePressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("RadioButtonOuterEllipseStrokePressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseStrokeDisabled")]
-						public static ResourceValue<Brush> Disabled => new("RadioButtonOuterEllipseStrokeDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("RadioButtonOuterEllipseStrokeDisabled");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedStroke")]
-						public static ResourceValue<Brush> Checked => new("RadioButtonOuterEllipseCheckedStroke", true);
+						public static ThemeResourceKey<Brush> Checked => new("RadioButtonOuterEllipseCheckedStroke");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedStrokePointerOver")]
-						public static ResourceValue<Brush> CheckedPointerOver => new("RadioButtonOuterEllipseCheckedStrokePointerOver", true);
+						public static ThemeResourceKey<Brush> CheckedPointerOver => new("RadioButtonOuterEllipseCheckedStrokePointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedStrokePressed")]
-						public static ResourceValue<Brush> CheckedPressed => new("RadioButtonOuterEllipseCheckedStrokePressed", true);
+						public static ThemeResourceKey<Brush> CheckedPressed => new("RadioButtonOuterEllipseCheckedStrokePressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedStrokeDisabled")]
-						public static ResourceValue<Brush> CheckedDisabled => new("RadioButtonOuterEllipseCheckedStrokeDisabled", true);
+						public static ThemeResourceKey<Brush> CheckedDisabled => new("RadioButtonOuterEllipseCheckedStrokeDisabled");
 					}
 
 					public static class Fill
 					{
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseFill")]
-						public static ResourceValue<Brush> Default => new("RadioButtonOuterEllipseFill", true);
+						public static ThemeResourceKey<Brush> Default => new("RadioButtonOuterEllipseFill");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseFillPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("RadioButtonOuterEllipseFillPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("RadioButtonOuterEllipseFillPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseFillPressed")]
-						public static ResourceValue<Brush> Pressed => new("RadioButtonOuterEllipseFillPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("RadioButtonOuterEllipseFillPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseFillDisabled")]
-						public static ResourceValue<Brush> Disabled => new("RadioButtonOuterEllipseFillDisabled", true);
+						public static ThemeResourceKey<Brush> Disabled => new("RadioButtonOuterEllipseFillDisabled");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedFill")]
-						public static ResourceValue<Brush> Checked => new("RadioButtonOuterEllipseCheckedFill", true);
+						public static ThemeResourceKey<Brush> Checked => new("RadioButtonOuterEllipseCheckedFill");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedFillPointerOver")]
-						public static ResourceValue<Brush> CheckedPointerOver => new("RadioButtonOuterEllipseCheckedFillPointerOver", true);
+						public static ThemeResourceKey<Brush> CheckedPointerOver => new("RadioButtonOuterEllipseCheckedFillPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedFillPressed")]
-						public static ResourceValue<Brush> CheckedPressed => new("RadioButtonOuterEllipseCheckedFillPressed", true);
+						public static ThemeResourceKey<Brush> CheckedPressed => new("RadioButtonOuterEllipseCheckedFillPressed");
 
 						[ResourceKeyDefinition(typeof(Brush), "RadioButtonOuterEllipseCheckedFillDisabled")]
-						public static ResourceValue<Brush> CheckedDisabled => new("RadioButtonOuterEllipseCheckedFillDisabled", true);
+						public static ThemeResourceKey<Brush> CheckedDisabled => new("RadioButtonOuterEllipseCheckedFillDisabled");
 					}
 
 					public static class HoverRingFill
 					{
 						[ResourceKeyDefinition(typeof(Brush), "MaterialRadioButtonHoverRingFillPointerOver")]
-						public static ResourceValue<Brush> PointerOver => new("MaterialRadioButtonHoverRingFillPointerOver", true);
+						public static ThemeResourceKey<Brush> PointerOver => new("MaterialRadioButtonHoverRingFillPointerOver");
 
 						[ResourceKeyDefinition(typeof(Brush), "MaterialRadioButtonHoverRingFillPressed")]
-						public static ResourceValue<Brush> Pressed => new("MaterialRadioButtonHoverRingFillPressed", true);
+						public static ThemeResourceKey<Brush> Pressed => new("MaterialRadioButtonHoverRingFillPressed");
 					}
 
 					public static class Typography
 					{
 						[ResourceKeyDefinition(typeof(FontFamily), "RadioButtonFontFamily")]
-						public static ResourceValue<FontFamily> FontFamily => new("RadioButtonFontFamily", true);
+						public static StaticResourceKey<FontFamily> FontFamily => new("RadioButtonFontFamily");
 
 						[ResourceKeyDefinition(typeof(FontWeights), "RadioButtonFontWeight")]
-						public static ResourceValue<FontWeights> FontWeight => new("RadioButtonFontWeight", true);
+						public static StaticResourceKey<FontWeights> FontWeight => new("RadioButtonFontWeight");
 
 						[ResourceKeyDefinition(typeof(double), "RadioButtonFontSize")]
-						public static ResourceValue<double> FontSize => new("RadioButtonFontSize", true);
+						public static StaticResourceKey<double> FontSize => new("RadioButtonFontSize");
 
 						[ResourceKeyDefinition(typeof(int), "RadioButtonCharacterSpacing")]
-						public static ResourceValue<int> CharacterSpacing => new("RadioButtonCharacterSpacing", true);
+						public static StaticResourceKey<int> CharacterSpacing => new("RadioButtonCharacterSpacing");
 					}
 				}
 			}
@@ -111,10 +112,10 @@ public static class Typography
 			public static class Styles
 			{
 				[ResourceKeyDefinition(typeof(Style), "RadioButtonStyle", TargetType = typeof(RadioButton))]
-				public static ResourceValue<Style> Default => new("RadioButtonStyle");
+				public static StaticResourceKey<Style> Default => new("RadioButtonStyle");
 
 				[ResourceKeyDefinition(typeof(Style), "SecondaryRadioButtonStyle", TargetType = typeof(RadioButton))]
-				public static ResourceValue<Style> Secondary => new("SecondaryRadioButtonStyle");
+				public static StaticResourceKey<Style> Secondary => new("SecondaryRadioButtonStyle");
 			}
 		}
 	}