diff --git a/WindowsAppRuntime.sln b/WindowsAppRuntime.sln
index f3158a85bb..11e3a1074c 100644
--- a/WindowsAppRuntime.sln
+++ b/WindowsAppRuntime.sln
@@ -348,6 +348,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DeploymentAgent", "dev\Depl
 		{B73AD907-6164-4294-88FB-F3C9C10DA1F1} = {B73AD907-6164-4294-88FB-F3C9C10DA1F1}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AppNotificationBuilder", "dev\AppNotifications\AppNotificationBuilder\AppNotificationBuilder.vcxitems", "{E49329F3-5196-4BBA-B5C4-E11CE7EFB07A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AppNotificationBuilderTests", "test\AppNotificationBuilderTests\AppNotificationBuilderTests.vcxproj", "{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}"
+EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Windows.Security.AccessControl.Projection", "dev\Projections\CS\Microsoft.Windows.Security.AccessControl.Projection\Microsoft.Windows.Security.AccessControl.Projection.csproj", "{E6D59245-696F-4D13-ACF6-7ECE6E653367}"
 EndProject
 Global
@@ -381,6 +385,7 @@ Global
 		dev\Deployment\Deployment.vcxitems*{db38fb4d-d04f-4c1d-93e0-f8ae259c5fd6}*SharedItemsImports = 9
 		dev\EnvironmentManager\ChangeTracker\ChangeTracker.vcxitems*{e15c3465-9d45-495d-92ce-b91ef45e8623}*SharedItemsImports = 9
 		dev\AppLifecycle\AppLifecycle.vcxitems*{e3a522a3-6635-4a42-bded-1af46a15f63c}*SharedItemsImports = 9
+		dev\AppNotifications\AppNotificationBuilder\AppNotificationBuilder.vcxitems*{e49329f3-5196-4bba-b5c4-e11ce7efb07a}*SharedItemsImports = 9
 		test\inc\inc.vcxitems*{e5659a29-fe68-417b-9bc5-613073dd54df}*SharedItemsImports = 4
 		test\inc\inc.vcxitems*{e977b1bd-00dc-4085-a105-e0a18e0183d7}*SharedItemsImports = 4
 	EndGlobalSection
@@ -1357,6 +1362,20 @@ Global
 		{4410D374-A90C-4ADF-8B15-AA2AAE2636BF}.Release|x64.Build.0 = Release|x64
 		{4410D374-A90C-4ADF-8B15-AA2AAE2636BF}.Release|x86.ActiveCfg = Release|x86
 		{4410D374-A90C-4ADF-8B15-AA2AAE2636BF}.Release|x86.Build.0 = Release|x86
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Debug|ARM64.Build.0 = Debug|ARM64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Debug|x64.ActiveCfg = Debug|x64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Debug|x64.Build.0 = Debug|x64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Debug|x86.ActiveCfg = Debug|Win32
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Debug|x86.Build.0 = Debug|Win32
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Release|Any CPU.ActiveCfg = Release|Win32
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Release|ARM64.ActiveCfg = Release|ARM64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Release|ARM64.Build.0 = Release|ARM64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Release|x64.ActiveCfg = Release|x64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Release|x64.Build.0 = Release|x64
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Release|x86.ActiveCfg = Release|Win32
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A}.Release|x86.Build.0 = Release|Win32
 		{E6D59245-696F-4D13-ACF6-7ECE6E653367}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{E6D59245-696F-4D13-ACF6-7ECE6E653367}.Debug|ARM64.ActiveCfg = Debug|arm64
 		{E6D59245-696F-4D13-ACF6-7ECE6E653367}.Debug|ARM64.Build.0 = Debug|arm64
@@ -1485,6 +1504,8 @@ Global
 		{D9139E3C-8D21-4BD9-84E3-30A03A54D610} = {99C514E4-A6B3-4B09-B870-5511EF9D93AC}
 		{4A74BBED-3B20-44A7-B6FF-3373160DE741} = {99C514E4-A6B3-4B09-B870-5511EF9D93AC}
 		{4410D374-A90C-4ADF-8B15-AA2AAE2636BF} = {E378857C-D22A-4E5E-A6DA-A59C445CF22E}
+		{E49329F3-5196-4BBA-B5C4-E11CE7EFB07A} = {1C9A0791-2BAA-420B-84B6-C0721F22A6E8}
+		{131DE0C4-AA1E-4649-B5BC-7B43508FA93A} = {8630F7AA-2969-4DC9-8700-9B468C1DC21D}
 		{E6D59245-696F-4D13-ACF6-7ECE6E653367} = {716C26A0-E6B0-4981-8412-D14A4D410531}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
diff --git a/dev/AppNotifications/AppNotificationActivatedEventArgs.cpp b/dev/AppNotifications/AppNotificationActivatedEventArgs.cpp
new file mode 100644
index 0000000000..8bceba0006
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationActivatedEventArgs.cpp
@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "AppNotificationActivatedEventArgs.h"
+#include "Microsoft.Windows.AppNotifications.AppNotificationActivatedEventArgs.g.cpp"
+#include "AppNotificationBuilder/AppNotificationBuilderUtility.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::implementation
+{
+    winrt::Windows::Foundation::Collections::IMap<hstring, hstring> AppNotificationActivatedEventArgs::DecodeArguments(std::wstring arguments)
+    {
+        auto result{ winrt::single_threaded_map<winrt::hstring, winrt::hstring>() };
+
+        std::vector<std::wstring> pairs{};
+        size_t pos{ 0 };
+
+        // Separate the key/value pairs by ';' as the delimiter
+        while ((pos = arguments.find(L';')) != std::wstring::npos)
+        {
+            pairs.push_back(arguments.substr(0, pos));
+            arguments.erase(0, pos + 1);
+        }
+
+        // Need to push back final string
+        pairs.push_back(arguments);
+
+        for (auto pair : pairs)
+        {
+            // Get the key/value individual values separated by '='
+            pos = pair.find(L'=');
+            if (pos == std::wstring::npos)
+            {
+                result.Insert(Decode(pair).c_str(), L"");
+            }
+            else
+            {
+                result.Insert(Decode(pair.substr(0, pos)).c_str(), Decode(pair.substr(pos + 1)).c_str());
+            }
+        }
+        return result;
+    }
+}
diff --git a/dev/AppNotifications/AppNotificationActivatedEventArgs.h b/dev/AppNotifications/AppNotificationActivatedEventArgs.h
index fe109d3709..7c9d400d01 100644
--- a/dev/AppNotifications/AppNotificationActivatedEventArgs.h
+++ b/dev/AppNotifications/AppNotificationActivatedEventArgs.h
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 #pragma once
@@ -10,12 +10,17 @@ namespace winrt::Microsoft::Windows::AppNotifications::implementation
     {
         AppNotificationActivatedEventArgs() = default;
 
-        AppNotificationActivatedEventArgs(winrt::hstring const& arguments, winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> const& userInput) : m_arguments(arguments), m_userInput(userInput) {};
-        winrt::hstring Argument() { return m_arguments; };
+        AppNotificationActivatedEventArgs(winrt::hstring const& argument, winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> const& userInput)
+            : m_argument(argument), m_userInput(userInput), m_arguments(DecodeArguments(argument.c_str())) {};
+        winrt::hstring Argument() { return m_argument; };
         winrt::Windows::Foundation::Collections::IMap<hstring, hstring> UserInput() { return m_userInput; };
+        winrt::Windows::Foundation::Collections::IMap<hstring, hstring> Arguments() { return m_arguments; };
 
     private:
-        winrt::hstring m_arguments;
+        winrt::Windows::Foundation::Collections::IMap<hstring, hstring> DecodeArguments(std::wstring arguments);
+
+        winrt::hstring m_argument;
         winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> m_userInput;
+        winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> m_arguments{ nullptr };
     };
 }
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.cpp b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.cpp
new file mode 100644
index 0000000000..46d2510564
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.cpp
@@ -0,0 +1,398 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "AppNotificationBuilder.h"
+#include <winrt/Windows.Globalization.h>
+#include <winrt/Windows.Globalization.DateTimeFormatting.h>
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationBuilder.g.cpp"
+#include "AppNotificationBuilderUtility.h"
+#include <iomanip>
+#include <ctime>
+#include <sstream>
+#include <IsWindowsVersion.h>
+
+using namespace winrt::Windows::Globalization;
+using namespace winrt::Windows::Globalization::DateTimeFormatting;
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    void AppNotificationBuilder::ThrowIfMaxInputItemsExceeded()
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, m_textBoxList.size() + m_comboBoxList.size() >= c_maxTextInputElements, "Maximum number of input elements added");
+    }
+
+    bool AppNotificationBuilder::IsUrgentScenarioSupported()
+    {
+        return WindowsVersion::IsWindows10_20H1OrGreater();
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddArgument(hstring const& key, hstring const& value)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, key.empty(), "You must provide a key when adding an argument");
+
+        m_arguments.Insert(EncodeArgument(key.c_str()), EncodeArgument(value.c_str()));
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetTimeStamp(winrt::Windows::Foundation::DateTime const& value)
+    {
+        auto seconds{ winrt::clock::to_time_t(value) };
+        struct tm buf{};
+        gmtime_s(&buf, &seconds);
+
+        std::wstringstream buffer;
+        buffer << std::put_time(&buf, L"%FT%T");
+
+        m_timeStamp = wil::str_printf<std::wstring>(L" displayTimestamp='%lsZ'", buffer.str().c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetScenario(AppNotificationScenario const& value)
+    {
+        m_scenario = value;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetDuration(AppNotificationDuration const& value)
+    {
+        m_duration = value;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddText(hstring const& text)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, m_textLines.size() >= c_maxTextElements, "Maximum number of text elements added");
+
+        m_textLines.push_back(wil::str_printf<std::wstring>(L"<text>%ls</text>", EncodeXml(text).c_str()).c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddText(hstring const& text, AppNotificationTextProperties const& properties)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, m_textLines.size() >= c_maxTextElements, "Maximum number of text elements added");
+
+        std::wstring props{ properties.as<winrt::Windows::Foundation::IStringable>().ToString() };
+        m_textLines.push_back(wil::str_printf<std::wstring>(L"%ls%ls</text>", props.c_str(), EncodeXml(text).c_str()).c_str());
+
+        if (properties.IncomingCallAlignment())
+        {
+            m_scenario = AppNotificationScenario::IncomingCall;
+        }
+        return *this;
+    }    
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAttributionText(hstring const& text)
+    {
+        m_attributionText = wil::str_printf<std::wstring>(L"<text placement='attribution'>%ls</text>", EncodeXml(text).c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAttributionText(hstring const& text, hstring const& language)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, language.empty(), "You must provide a language calling SetAttributionText");
+
+        m_attributionText = wil::str_printf<std::wstring>(L"<text placement='attribution' lang='%ls'>%ls</text>", language.c_str(), EncodeXml(text).c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetInlineImage(winrt::Windows::Foundation::Uri const& imageUri)
+    {
+        m_inlineImage = wil::str_printf<std::wstring>(L"<image src='%ls'/>", imageUri.ToString().c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetInlineImage(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop)
+    {
+        if (imageCrop == AppNotificationImageCrop::Circle)
+        {
+            m_inlineImage = wil::str_printf<std::wstring>(L"<image src='%ls' hint-crop='circle'/>", imageUri.ToString().c_str());
+        }
+        else
+        {
+            SetInlineImage(imageUri);
+        }
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetInlineImage(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop, hstring const& alternateText)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, alternateText.empty(), "You must provide an alternate text string calling SetInlineImage");
+
+        std::wstring hintCrop { imageCrop == AppNotificationImageCrop::Circle ? L" hint-crop='circle'" : L"" };
+        m_inlineImage = wil::str_printf<std::wstring>(L"<image src='%ls' alt='%ls'%ls/>", imageUri.ToString().c_str(), EncodeXml(alternateText).c_str(), hintCrop.c_str());
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAppLogoOverride(winrt::Windows::Foundation::Uri const& imageUri)
+    {
+        m_appLogoOverride = wil::str_printf<std::wstring>(L"<image placement='appLogoOverride' src='%ls'/>", imageUri.ToString().c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAppLogoOverride(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop)
+    {
+        if (imageCrop == AppNotificationImageCrop::Circle)
+        {
+            m_appLogoOverride = wil::str_printf<std::wstring>(L"<image placement='appLogoOverride' src='%ls' hint-crop='circle'/>", imageUri.ToString().c_str());
+        }
+        else
+        {
+            SetAppLogoOverride(imageUri);
+        }
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAppLogoOverride(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop, hstring const& alternateText)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, alternateText.empty(), "You must provide an alternate text string calling SetAppLogoOverride");
+
+        std::wstring hintCrop{ imageCrop == AppNotificationImageCrop::Circle ? L" hint-crop='circle'" : L"" };
+        m_appLogoOverride = wil::str_printf<std::wstring>(L"<image placement='appLogoOverride' src='%ls' alt='%ls'%ls/>", imageUri.ToString().c_str(), EncodeXml(alternateText).c_str(), hintCrop.c_str());
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetHeroImage(winrt::Windows::Foundation::Uri const& imageUri)
+    {
+        m_heroImage = wil::str_printf<std::wstring>(L"<image placement='hero' src='%ls'/>", imageUri.ToString().c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetHeroImage(winrt::Windows::Foundation::Uri const& imageUri, hstring const& alternateText)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, alternateText.empty(), "You must provide an alternate text string calling SetHeroImage");
+
+        m_heroImage = wil::str_printf<std::wstring>(L"<image placement='hero' src='%ls' alt='%ls'/>", imageUri.ToString().c_str(), EncodeXml(alternateText).c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAudioUri(winrt::Windows::Foundation::Uri const& audioUri)
+    {
+        m_audio = wil::str_printf<std::wstring>(L"<audio src='%ls'/>", audioUri.ToString().c_str());
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAudioUri(winrt::Windows::Foundation::Uri const& audioUri, AppNotificationAudioLooping const& loop)
+    {
+        m_audio = wil::str_printf<std::wstring>(L"<audio src='%ls' loop='%ls'/>", audioUri.ToString().c_str(), loop == AppNotificationAudioLooping::Loop ? L"true" : L"false");
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAudioEvent(AppNotificationSoundEvent const& soundEvent)
+    {
+        m_audio = wil::str_printf<std::wstring>(L"<audio src='%ls'/>", GetWinSoundEventString(soundEvent));
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetAudioEvent(AppNotificationSoundEvent const& soundEvent, AppNotificationAudioLooping const& loop)
+    {
+        m_audio = wil::str_printf<std::wstring>(L"<audio src='%ls' loop='%ls'/>", GetWinSoundEventString(soundEvent), loop == AppNotificationAudioLooping::Loop ? L"true" : L"false");
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::MuteAudio()
+    {
+        m_audio = L"<audio silent='true'/>";
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddProgressBar(AppNotificationProgressBar const& value)
+    {
+        m_progressBarList.push_back(value);
+
+        return *this;
+    }
+    
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddTextBox(hstring id)
+    {
+        ThrowIfMaxInputItemsExceeded();
+        THROW_HR_IF_MSG(E_INVALIDARG, id.empty(), "You must provide an id for the TextBox");
+
+
+        m_textBoxList.push_back(wil::str_printf<std::wstring>(L"<input id='%ls' type='text'/>", EncodeXml(id).c_str()));
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddTextBox(hstring id, hstring placeHolderText, hstring title)
+    {
+        ThrowIfMaxInputItemsExceeded();
+        THROW_HR_IF_MSG(E_INVALIDARG, id.empty(), "You must provide an id for the TextBox");
+
+        m_textBoxList.push_back(wil::str_printf<std::wstring>(L"<input id='%ls' type='text' placeHolderContent='%ls' title='%ls'/>", EncodeXml(id).c_str(), EncodeXml(placeHolderText).c_str(), EncodeXml(title).c_str()));
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddButton(AppNotificationButton const& value)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, m_buttonList.size() >= c_maxButtonElements, "Maximum number of buttons added");
+
+        m_buttonList.push_back(value);
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::AddComboBox(AppNotificationComboBox const& value)
+    {
+        ThrowIfMaxInputItemsExceeded();
+
+        m_comboBoxList.push_back(value);
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetTag(hstring const& value)
+    {
+        m_tag = value;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AppNotificationBuilder::SetGroup(hstring const& value)
+    {
+        m_group = value;
+        return *this;
+    }
+
+    std::wstring AppNotificationBuilder::GetDuration()
+    {
+        return m_duration == AppNotificationDuration::Default ? L"" : L" duration='long'";
+    }
+
+    std::wstring AppNotificationBuilder::GetScenario()
+    {
+        // Add scenario attribute if set
+        switch (m_scenario)
+        {
+        case AppNotificationScenario::Alarm:
+            return L" scenario='alarm'";
+        case AppNotificationScenario::Reminder:
+            return L" scenario='reminder'";
+        case AppNotificationScenario::IncomingCall:
+            return L" scenario='incomingCall'";
+        case AppNotificationScenario::Urgent:
+            return L" scenario='urgent'";
+        default:
+            return {};
+        }
+    }
+
+    std::wstring AppNotificationBuilder::GetArguments()
+    {
+        // Add launch arguments if given arguments
+        if (m_arguments.Size())
+        {
+            std::wstring arguments;
+            for (auto pair : m_arguments)
+            {
+                if (!pair.Value().empty())
+                {
+                    arguments.append(wil::str_printf<std::wstring>(L"%ls=%ls;", pair.Key().c_str(), pair.Value().c_str()));
+                }
+                else
+                {
+                    arguments.append(wil::str_printf<std::wstring>(L"%ls;", pair.Key().c_str()));
+                }
+            }
+            arguments.pop_back();
+
+            return wil::str_printf<std::wstring>(L" launch='%ls'", arguments.c_str());
+        }
+        else
+        {
+            return {};
+        }
+    }
+
+    std::wstring AppNotificationBuilder::GetText()
+    {
+        std::wstring result{};
+        for (auto text : m_textLines)
+        {
+            result.append(text);
+        }
+
+        return result;
+    }
+
+    std::wstring AppNotificationBuilder::GetImages()
+    {
+        return wil::str_printf<std::wstring>(L"%ls%ls%ls", m_inlineImage.c_str(), m_heroImage.c_str(), m_appLogoOverride.c_str());
+    }
+
+    std::wstring AppNotificationBuilder::GetActions()
+    {
+
+        std::wstring result{};
+        for (auto input : m_textBoxList)
+        {
+            result.append(input.c_str());
+        }
+
+        for (auto input : m_comboBoxList)
+        {
+            result.append(input.as<winrt::Windows::Foundation::IStringable>().ToString().c_str());
+        }
+
+        for (auto input : m_buttonList)
+        {
+            if (input.ButtonStyle() != AppNotificationButtonStyle::Default)
+            {
+                m_useButtonStyle = true;
+            }
+
+            result.append(input.as<winrt::Windows::Foundation::IStringable>().ToString().c_str());
+        }
+
+        return (result.empty()) ? result : wil::str_printf<std::wstring>(L"<actions>%ls</actions>", result.c_str());
+    }
+
+    // You must call GetActions first to retrieve this value.
+    std::wstring AppNotificationBuilder::GetButtonStyle()
+    {
+        return m_useButtonStyle ? L" useButtonStyle='true'" : L"";
+    }
+
+    std::wstring AppNotificationBuilder::GetProgressBars()
+    {
+        std::wstring result{};
+        for (auto progressBar : m_progressBarList)
+        {
+            result.append(progressBar.as<winrt::Windows::Foundation::IStringable>().ToString());
+        }
+
+        return result;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::AppNotification AppNotificationBuilder::BuildNotification()
+    {
+        // Build the button string and fill m_useButtonStyle
+        std::wstring actions{ GetActions() };
+
+        auto xmlResult{ wil::str_printf<std::wstring>(L"%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls",
+            L"<toast",
+            m_timeStamp.c_str(),
+            GetDuration().c_str(),
+            GetScenario().c_str(),
+            GetArguments().c_str(),
+            GetButtonStyle().c_str(),
+            L"><visual><binding template='ToastGeneric'>",
+            GetText().c_str(),
+            m_attributionText.c_str(),
+            GetImages().c_str(),
+            GetProgressBars().c_str(),
+            L"</binding></visual>",
+            m_audio.c_str(),
+            actions.c_str(),
+            L"</toast>") };
+
+        THROW_HR_IF_MSG(E_INVALIDARG, xmlResult.size() > c_maxAppNotificationPayload, "Maximum payload size exceeded");
+
+        winrt::Microsoft::Windows::AppNotifications::AppNotification appNotification{ xmlResult };
+        appNotification.Tag(m_tag);
+        appNotification.Group(m_group);
+        
+        return appNotification;
+    }
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.h b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.h
new file mode 100644
index 0000000000..8433aceac6
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.h
@@ -0,0 +1,103 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#pragma once
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationBuilder.g.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    struct AppNotificationBuilder : AppNotificationBuilderT<AppNotificationBuilder>
+    {
+        AppNotificationBuilder() = default;
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddArgument(hstring const& key, hstring const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetTimeStamp(winrt::Windows::Foundation::DateTime const& value);
+        
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetScenario(AppNotificationScenario const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetDuration(AppNotificationDuration const& value);
+
+        // Text component APIs
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddText(hstring const& text);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddText(hstring const& text, AppNotificationTextProperties const& properties);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAttributionText(hstring const& text);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAttributionText(hstring const& text, hstring const& language);
+
+        // Inline image component APIs
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetInlineImage(winrt::Windows::Foundation::Uri const& imageUri);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetInlineImage(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetInlineImage(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop, winrt::hstring const& alternateText);
+
+        // AppLogoOverride component APIs
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAppLogoOverride(winrt::Windows::Foundation::Uri const& imageUri);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAppLogoOverride(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAppLogoOverride(winrt::Windows::Foundation::Uri const& imageUri, AppNotificationImageCrop const& imageCrop, winrt::hstring const& alternateText);
+
+        // Hero image component APIs
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetHeroImage(winrt::Windows::Foundation::Uri const& imageUri);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetHeroImage(winrt::Windows::Foundation::Uri const& imageUri, winrt::hstring const& alternateText);
+
+        // SetAudio
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAudioUri(winrt::Windows::Foundation::Uri const& audioUri);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAudioUri(winrt::Windows::Foundation::Uri const& audioUri, AppNotificationAudioLooping const& loop);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAudioEvent(AppNotificationSoundEvent const& soundEvent);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetAudioEvent(AppNotificationSoundEvent const& soundEvent, AppNotificationAudioLooping const& loop);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder MuteAudio();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddTextBox(hstring id);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddTextBox(hstring id, hstring placeHolderText, hstring title);
+
+        // Adds a button to the AppNotificationBuilder
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddButton(AppNotificationButton const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddProgressBar(AppNotificationProgressBar const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder AddComboBox(AppNotificationComboBox const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetTag(winrt::hstring const& value);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationBuilder SetGroup(winrt::hstring const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::AppNotification BuildNotification();
+
+        static bool IsUrgentScenarioSupported();
+
+    private:
+        void ThrowIfMaxInputItemsExceeded();
+        std::wstring GetDuration();
+        std::wstring GetScenario();
+        std::wstring GetArguments();
+        std::wstring GetButtonStyle();
+        std::wstring GetText();
+        std::wstring GetImages();
+        std::wstring GetActions();
+        std::wstring GetProgressBars();
+
+        std::wstring m_timeStamp{};
+        AppNotificationDuration m_duration{ AppNotificationDuration::Default };
+        AppNotificationScenario m_scenario{ AppNotificationScenario::Default };
+        bool m_useButtonStyle{};
+        std::vector<winrt::hstring> m_textLines{};
+        winrt::hstring m_attributionText{};
+        winrt::hstring m_inlineImage{};
+        winrt::hstring m_appLogoOverride{};
+        winrt::hstring m_heroImage{};
+        winrt::hstring m_audio{};
+        winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> m_arguments{ winrt::single_threaded_map<winrt::hstring, winrt::hstring>() };
+        std::vector<AppNotificationButton> m_buttonList{};
+        std::vector<AppNotificationProgressBar> m_progressBarList{};
+        std::vector<std::wstring> m_textBoxList{};
+        std::vector<AppNotificationComboBox> m_comboBoxList{};
+        winrt::hstring m_tag{};
+        winrt::hstring m_group{};
+    };
+}
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::factory_implementation
+{
+    struct AppNotificationBuilder : AppNotificationBuilderT<AppNotificationBuilder, implementation::AppNotificationBuilder>
+    {
+    };
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.idl b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.idl
new file mode 100644
index 0000000000..a8c7ff9c9c
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.idl
@@ -0,0 +1,232 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+import "..\AppNotifications\AppNotifications.idl";
+
+namespace Microsoft.Windows.AppNotifications.Builder
+{
+    runtimeclass AppNotificationTextProperties
+    {
+        // Contains the set of <text> attributes
+        AppNotificationTextProperties();
+
+        String Language;
+        Boolean IncomingCallAlignment;
+        Int32 MaxLines;
+
+        AppNotificationTextProperties SetLanguage(String value);
+        AppNotificationTextProperties SetIncomingCallAlignment();
+        AppNotificationTextProperties SetMaxLines(Int32 value);
+    };
+
+    enum AppNotificationButtonStyle
+    {
+        Default,
+        Success,
+        Critical,
+    };
+
+    runtimeclass AppNotificationButton
+    {
+        AppNotificationButton();
+        AppNotificationButton(String content);
+
+        String Content;
+        Windows.Foundation.Collections.IMap<String, String> Arguments;
+        Windows.Foundation.Uri Icon;
+        String ToolTip;
+        Boolean ContextMenuPlacement;
+        AppNotificationButtonStyle ButtonStyle;
+        String InputId;
+        Windows.Foundation.Uri InvokeUri;
+        String TargetAppId;
+
+        AppNotificationButton AddArgument(String key, String value);
+
+        // Sets the Icon for the button.
+        AppNotificationButton SetIcon(Windows.Foundation.Uri value);
+
+        // The tooltip for a button, if the button has an empty content string.
+        AppNotificationButton SetToolTip(String value);
+        static Boolean IsToolTipSupported();
+
+        // Sets the Button as context menu action.
+        AppNotificationButton SetContextMenuPlacement();
+
+        // Sets the ButtonStyle to Success or Critical
+        AppNotificationButton SetButtonStyle(AppNotificationButtonStyle value);
+        static Boolean IsButtonStyleSupported();
+
+        // Specifies the ID of an existing TextBox next to which the button will be placed.
+        AppNotificationButton SetInputId(String value);
+
+        // Launches the URI passed into the button when activated.
+        AppNotificationButton SetInvokeUri(Windows.Foundation.Uri protocolUri);
+        AppNotificationButton SetInvokeUri(Windows.Foundation.Uri protocolUri, String targetAppId);
+    };
+
+    runtimeclass AppNotificationProgressBar
+    {
+        // AppNotificationProgressBar binds to AppNotificationProgressData so the AppNotification will
+        // receive every update to the status and value. In the WinAppSDK, these binding
+        // values are static, so developers won't need to define these binding values
+        // themselves.
+        AppNotificationProgressBar();
+
+        // Setting these properties will remove the data binding with a static value
+        String Title;
+        String Status;
+        Double Value;
+        String ValueStringOverride;
+
+        AppNotificationProgressBar SetTitle(String value);
+        AppNotificationProgressBar BindTitle();
+
+        AppNotificationProgressBar SetStatus(String value);
+        AppNotificationProgressBar BindStatus();
+
+        AppNotificationProgressBar SetValue(Double value);
+        AppNotificationProgressBar BindValue();
+
+        AppNotificationProgressBar SetValueStringOverride(String value);
+        AppNotificationProgressBar BindValueStringOverride();
+    };
+
+    runtimeclass AppNotificationComboBox
+    {
+        AppNotificationComboBox(String id);
+
+        Windows.Foundation.Collections.IMap<String, String> Items;
+        String Title;
+        String SelectedItem;
+
+        // Add a selection to the AppNotificationComboBox. The id parameter identifies the item the user selected.
+        AppNotificationComboBox AddItem(String id, String content);
+
+        // Adds a title to display on top
+        AppNotificationComboBox SetTitle(String value);
+
+        // Sets the default selection to be displayed by the AppNotificationComboBox
+        AppNotificationComboBox SetSelectedItem(String id);
+    };
+
+    enum AppNotificationSoundEvent
+    {
+        Default,
+        IM,
+        Mail,
+        Reminder,
+        SMS,
+        Alarm,
+        Alarm2,
+        Alarm3,
+        Alarm4,
+        Alarm5,
+        Alarm6,
+        Alarm7,
+        Alarm8,
+        Alarm9,
+        Alarm10,
+        Call,
+        Call2,
+        Call3,
+        Call4,
+        Call5,
+        Call6,
+        Call7,
+        Call8,
+        Call9,
+        Call10,
+    };
+
+    enum AppNotificationScenario
+    {
+        Default, // The normal AppNotification behavior. The AppNotification appears for a short duration, and then automatically dismisses into Notification Center.
+        Reminder, // The notification will stay on screen until the user dismisses it or takes action.
+        Alarm,    // Alarms behave like Reminder, but alarms will additionally loop audio with a default alarm sound.
+        IncomingCall, // Incoming call notifications are displayed pre-expanded in a special call format and stay on the user's screen till dismissed.
+        Urgent, // Important notifications allow users to have more control over what 1st party and 3rd party apps can send them high-priority AppNotifications (urgent/important) that can break through Focus Assist.
+    };
+
+    enum AppNotificationAudioLooping
+    {
+        None, // Audio will not loop
+        Loop, // Audio will loop for the duration of the AppNotification
+    };
+
+    enum AppNotificationDuration
+    {
+        Default, // Default value. AppNotification appears for a short while and then goes into Notification Center.
+        Long, // AppNotification stays on-screen for longer, and then goes into Notification Center.
+    };
+
+    enum AppNotificationImageCrop
+    {
+        Default, // Uses the default renderer to display the image
+        Circle, // Crops the image as a circle.
+    };
+
+    runtimeclass AppNotificationBuilder
+    {
+        AppNotificationBuilder();
+
+        // Adds arguments to the launch attribute to return when AppNotification is clicked.
+        AppNotificationBuilder AddArgument(String key, String value);
+
+        // Sets the timeStamp of the AppNotification to when it was constructed instead of when it was sent.
+        AppNotificationBuilder SetTimeStamp(Windows.Foundation.DateTime value);
+
+        AppNotificationBuilder SetDuration(AppNotificationDuration duration);
+
+        // Sets the scenario of the AppNotification.
+        AppNotificationBuilder SetScenario(AppNotificationScenario value);
+        static Boolean IsUrgentScenarioSupported();
+
+        // Adds text to the AppNotification.
+        AppNotificationBuilder AddText(String text);
+        AppNotificationBuilder AddText(String text, AppNotificationTextProperties properties);
+
+        AppNotificationBuilder SetAttributionText(String text);
+        AppNotificationBuilder SetAttributionText(String text, String language);
+
+        // Sets the full-width inline-image that appears when you expand the AppNotification
+        AppNotificationBuilder SetInlineImage(Windows.Foundation.Uri imageUri);
+        AppNotificationBuilder SetInlineImage(Windows.Foundation.Uri imageUri, AppNotificationImageCrop imageCrop);
+        AppNotificationBuilder SetInlineImage(Windows.Foundation.Uri imageUri, AppNotificationImageCrop imagecrop, String alternateText);
+
+        // Sets the image that replaces the app logo
+        AppNotificationBuilder SetAppLogoOverride(Windows.Foundation.Uri imageUri);
+        AppNotificationBuilder SetAppLogoOverride(Windows.Foundation.Uri imageUri, AppNotificationImageCrop imageCrop);
+        AppNotificationBuilder SetAppLogoOverride(Windows.Foundation.Uri imageUri, AppNotificationImageCrop imageCrop, String alternateText);
+
+        // Sets the image that displays within the banner of the AppNotification.
+        AppNotificationBuilder SetHeroImage(Windows.Foundation.Uri imageUri);
+        AppNotificationBuilder SetHeroImage(Windows.Foundation.Uri imageUri, String alternateText);
+
+        // SetAudio
+        AppNotificationBuilder SetAudioUri(Windows.Foundation.Uri audioUri);
+        AppNotificationBuilder SetAudioUri(Windows.Foundation.Uri audioUri, AppNotificationAudioLooping loop);
+
+        AppNotificationBuilder SetAudioEvent(AppNotificationSoundEvent appNotificationSoundEvent);
+        AppNotificationBuilder SetAudioEvent(AppNotificationSoundEvent appNotificationSoundEvent, AppNotificationAudioLooping loop);
+
+        AppNotificationBuilder MuteAudio();
+
+        AppNotificationBuilder AddTextBox(String id);
+        AppNotificationBuilder AddTextBox(String id, String placeHolderText, String title);
+
+        // Adds a button to the AppNotificationBuilder
+        AppNotificationBuilder AddButton(AppNotificationButton value);
+
+        AppNotificationBuilder AddComboBox(AppNotificationComboBox value);
+
+        AppNotificationBuilder AddProgressBar(AppNotificationProgressBar value);
+
+        // Constructs a WindowsAppSDK AppNotification object with the XML payload
+        Microsoft.Windows.AppNotifications.AppNotification BuildNotification();
+
+        // AppNotification properties
+        AppNotificationBuilder SetTag(String value);
+        AppNotificationBuilder SetGroup(String group);
+    };
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.vcxitems b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.vcxitems
new file mode 100644
index 0000000000..84cd82cdd0
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilder.vcxitems
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <MSBuildAllProjects Condition="'$(MSBuildVersion)' == '' Or '$(MSBuildVersion)' &lt; '16.0'">$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <ItemsProjectGuid>{e49329f3-5196-4bba-b5c4-e11ce7efb07a}</ItemsProjectGuid>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories);$(MSBuildThisFileDirectory)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectCapability Include="SourceItemsFromImports" />
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="$(MSBuildThisFileDirectory)AppNotificationBuilder.idl" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationBuilder.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationButton.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationProgressBar.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationComboBox.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationTextProperties.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="$(MSBuildThisFileDirectory)AppNotificationBuilder.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)AppNotificationBuilderUtility.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)AppNotificationButton.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)AppNotificationProgressBar.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)AppNotificationComboBox.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)AppNotificationTextProperties.h" />
+  </ItemGroup>
+</Project>
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilderUtility.h b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilderUtility.h
new file mode 100644
index 0000000000..5d270b80c1
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationBuilderUtility.h
@@ -0,0 +1,166 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "winrt/Microsoft.Windows.AppNotifications.Builder.h"
+#include <algorithm>
+#include <regex>
+#include <map>
+#include <iostream>
+
+constexpr size_t c_maxAppNotificationPayload{ 5120 };
+constexpr uint8_t c_maxTextElements{ 3 };
+constexpr uint8_t c_maxButtonElements{ 5 };
+constexpr size_t c_maxEncodingSize{ 3 };
+constexpr uint8_t c_maxTextInputElements{ 5 };
+constexpr uint8_t c_maxSelectionElements{ 5 };
+
+namespace AppNotificationBuilder
+{
+    using namespace winrt::Microsoft::Windows::AppNotifications::Builder;
+}
+
+inline std::unordered_map<wchar_t, std::wstring> GetXmlEscapeEncodings()
+{
+    static std::unordered_map<wchar_t, std::wstring> encodings = { { L'&', L"&amp;"}, { L'\"', L"&quot;"}, {L'<', L"&lt;"}, {L'>', L"&gt;"}, {L'\'', L"&apos;"}};
+    return encodings;
+}
+
+inline std::unordered_map<wchar_t, std::wstring> GetPercentEncodings()
+{
+    static std::unordered_map<wchar_t, std::wstring> encodings = {{ L'%', L"%25"}, {L';', L"%3B"}, {L'=', L"%3D"} };
+    return encodings;
+}
+
+inline std::unordered_map<std::wstring, wchar_t> GetPercentEncodingsReverse()
+{
+    static std::unordered_map<std::wstring, wchar_t> encodings = { { L"%25", L'%' }, {L"%3B", L';' }, { L"%3D", L'=' } };
+    return encodings;
+}
+
+inline PCWSTR GetWinSoundEventString(AppNotificationBuilder::AppNotificationSoundEvent soundEvent)
+{
+    switch (soundEvent)
+    {
+    case AppNotificationBuilder::AppNotificationSoundEvent::IM:
+        return L"ms-winsoundevent:Notification.IM";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Mail:
+        return L"ms-winsoundevent:Notification.Mail";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Reminder:
+        return L"ms-winsoundevent:Notification.Reminder";
+    case AppNotificationBuilder::AppNotificationSoundEvent::SMS:
+        return L"ms-winsoundevent:Notification.SMS";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm:
+        return L"ms-winsoundevent:Notification.Looping.Alarm";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm2:
+        return L"ms-winsoundevent:Notification.Looping.Alarm2";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm3:
+        return L"ms-winsoundevent:Notification.Looping.Alarm3";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm4:
+        return L"ms-winsoundevent:Notification.Looping.Alarm4";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm5:
+        return L"ms-winsoundevent:Notification.Looping.Alarm5";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm6:
+        return L"ms-winsoundevent:Notification.Looping.Alarm6";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm7:
+        return L"ms-winsoundevent:Notification.Looping.Alarm7";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm8:
+        return L"ms-winsoundevent:Notification.Looping.Alarm8";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm9:
+        return L"ms-winsoundevent:Notification.Looping.Alarm9";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Alarm10:
+        return L"ms-winsoundevent:Notification.Looping.Alarm10";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call:
+        return L"ms-winsoundevent:Notification.Looping.Call";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call2:
+        return L"ms-winsoundevent:Notification.Looping.Call2";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call3:
+        return L"ms-winsoundevent:Notification.Looping.Call3";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call4:
+        return L"ms-winsoundevent:Notification.Looping.Call4";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call5:
+        return L"ms-winsoundevent:Notification.Looping.Call5";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call6:
+        return L"ms-winsoundevent:Notification.Looping.Call6";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call7:
+        return L"ms-winsoundevent:Notification.Looping.Call7";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call8:
+        return L"ms-winsoundevent:Notification.Looping.Call8";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call9:
+        return L"ms-winsoundevent:Notification.Looping.Call9";
+    case AppNotificationBuilder::AppNotificationSoundEvent::Call10:
+        return L"ms-winsoundevent:Notification.Looping.Call10";
+    default:
+        return L"ms-winsoundevent:Notification.Default";
+    }
+}
+
+inline std::wstring EncodeArgument(std::wstring const& value)
+{
+    std::wstring encodedValue{};
+
+    auto percentEncodings{ GetPercentEncodings() };
+    auto xmlEncodings{ GetXmlEscapeEncodings() };
+    for (auto ch : value)
+    {
+        if (percentEncodings.find(ch) != percentEncodings.end())
+        {
+            encodedValue.append(percentEncodings[ch]);
+        }
+        else if (xmlEncodings.find(ch) != xmlEncodings.end())
+        {
+            encodedValue.append(xmlEncodings[ch]);
+        }
+        else
+        {
+            encodedValue.push_back(ch);
+        }
+    }
+
+    return encodedValue;
+}
+
+inline std::wstring EncodeXml(winrt::hstring const& value)
+{
+    std::wstring encodedValue{};
+
+    auto xmlEncodings{ GetXmlEscapeEncodings() };
+    for (auto ch : value)
+    {
+        if (xmlEncodings.find(ch) != xmlEncodings.end())
+        {
+            encodedValue.append(xmlEncodings[ch]);
+        }
+        else
+        {
+            encodedValue.push_back(ch);
+        }
+    }
+
+    return encodedValue;
+}
+
+// Decoding process based off the Windows Community Toolkit:
+// https://github.com/CommunityToolkit/WindowsCommunityToolkit/blob/rel/7.1.0/Microsoft.Toolkit.Uwp.Notifications/Toasts/ToastArguments.cs#L389inline
+inline std::wstring Decode(std::wstring const& value)
+{
+    std::wstring result{};
+    auto percentEncodings{ GetPercentEncodingsReverse() };
+
+    // Need to unescape special characters
+    for (size_t index = 0; index < value.size();)
+    {
+        std::wstring curr{ value.substr(index, c_maxEncodingSize) };
+        if (percentEncodings.find(curr) != percentEncodings.end())
+        {
+            result.push_back(percentEncodings[curr]);
+            index += c_maxEncodingSize;
+        }
+        else
+        {
+            result.push_back(value.at(index));
+            index++;
+        }
+    }
+    return result;
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationButton.cpp b/dev/AppNotifications/AppNotificationBuilder/AppNotificationButton.cpp
new file mode 100644
index 0000000000..dafb587ea1
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationButton.cpp
@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "AppNotificationButton.h"
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationButton.g.cpp"
+#include <IsWindowsVersion.h>
+#include "AppNotificationBuilderUtility.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    AppNotificationButton::AppNotificationButton(winrt::hstring const& content) : m_content(content) { };
+
+    bool AppNotificationButton::IsToolTipSupported()
+    {
+        return WindowsVersion::IsWindows10_20H1OrGreater();
+    }
+
+    bool AppNotificationButton::IsButtonStyleSupported()
+    {
+        return WindowsVersion::IsWindows10_20H1OrGreater();
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::AddArgument(winrt::hstring const& key, winrt::hstring const& value)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, key.empty(), "You must provide a key when adding an argument");
+        THROW_HR_IF_MSG(E_INVALIDARG, m_protocolUri, "You cannot add an argument after calling SetInvokeUri");
+
+        m_arguments.Insert(EncodeArgument(key.c_str()), EncodeArgument(value.c_str()));
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::SetIcon(winrt::Windows::Foundation::Uri const& value)
+    {
+        m_iconUri = value;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::SetToolTip(winrt::hstring const& value)
+    {
+        m_toolTip = EncodeXml(value.c_str()).c_str();
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::SetContextMenuPlacement()
+    {
+        m_useContextMenuPlacement = true;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::SetButtonStyle(AppNotificationButtonStyle const& value)
+    {
+        m_buttonStyle = value;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::SetInputId(winrt::hstring const& value)
+    {
+        m_inputId = EncodeXml(value.c_str()).c_str();
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::SetInvokeUri(winrt::Windows::Foundation::Uri const& protocolUri)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, m_arguments.Size() > 0u, "You cannot add a protocol activation uri after calling AddArgument");
+
+        m_protocolUri = protocolUri;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AppNotificationButton::SetInvokeUri(winrt::Windows::Foundation::Uri const& protocolUri, winrt::hstring const& targetAppId)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, m_arguments.Size() > 0u, "You cannot add a protocol activation uri after calling AddArgument");
+
+        m_protocolUri = protocolUri;
+        m_targetApplicationPfn = targetAppId;
+        return *this;
+    }
+
+    std::wstring AppNotificationButton::GetActivationArguments()
+    {
+        if (m_protocolUri)
+        {
+            std::wstring protocolTargetPfn{ !m_targetApplicationPfn.empty() ? wil::str_printf<std::wstring>(L" protocolActivationTargetApplicationPfn='%ls'", m_targetApplicationPfn.c_str()) : L"" };
+            return wil::str_printf<std::wstring>(L" arguments='%ws' activationType='protocol'%ls", m_protocolUri.ToString().c_str(), protocolTargetPfn.c_str());
+        }
+        else
+        {
+            std::wstring arguments;
+            for (auto pair : m_arguments)
+            {
+                if (!pair.Value().empty())
+                {
+                    arguments.append(wil::str_printf<std::wstring>(L"%ls=%ls;", pair.Key().c_str(), pair.Value().c_str()));
+                }
+                else
+                {
+                    arguments.append(wil::str_printf<std::wstring>(L"%ls;", pair.Key().c_str()));
+                }
+            }
+            arguments.pop_back();
+
+            return wil::str_printf<std::wstring>(L" arguments='%ls'", arguments.c_str());
+        }
+    }
+
+    std::wstring AppNotificationButton::GetButtonStyle()
+    {
+        if (m_buttonStyle == AppNotificationButtonStyle::Default)
+        {
+            return L"";
+        }
+
+        std::wstring style{ m_buttonStyle == AppNotificationButtonStyle::Success ? L"Success" : L"Critical" };
+        return wil::str_printf<std::wstring>(L" hint-buttonStyle='%ls'", style.c_str());
+    }
+
+    winrt::hstring AppNotificationButton::ToString()
+    {
+        std::wstring xmlResult{ wil::str_printf<std::wstring>(L"<action content='%ls'%ls%ls%ls%ls%ls%ls/>",
+            m_content.c_str(),
+            GetActivationArguments().c_str(),
+            m_useContextMenuPlacement ? L" placement='contextMenu'" : L"",
+            m_iconUri ? wil::str_printf<std::wstring>(L" imageUri='%ls'", m_iconUri.ToString().c_str()).c_str() : L"",
+            !m_inputId.empty() ? wil::str_printf<std::wstring>(L" hint-inputId='%ls'", m_inputId.c_str()).c_str() : L"",
+            GetButtonStyle().c_str(),
+            !m_toolTip.empty() ? wil::str_printf<std::wstring>(L" hint-toolTip='%ls'", m_toolTip.c_str()).c_str() : L"") };
+
+        return xmlResult.c_str();
+    }
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationButton.h b/dev/AppNotifications/AppNotificationBuilder/AppNotificationButton.h
new file mode 100644
index 0000000000..214db26094
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationButton.h
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#pragma once
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationButton.g.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+
+    struct AppNotificationButton : AppNotificationButtonT<AppNotificationButton, winrt::Windows::Foundation::IStringable>
+    {
+        AppNotificationButton() = default;
+        AppNotificationButton(winrt::hstring const& content);
+
+        // Properties
+        void Content(winrt::hstring const& value) { m_content = value; };
+        winrt::hstring Content() { return m_content; };
+
+        void Arguments(winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> const& value) { m_arguments = value; };
+        winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> Arguments() { return m_arguments; };
+
+        void Icon(winrt::Windows::Foundation::Uri const& value) { m_iconUri = value; };
+        winrt::Windows::Foundation::Uri Icon() { return m_iconUri; };
+
+        void ToolTip(winrt::hstring const& value) { m_toolTip = value; };
+        winrt::hstring ToolTip() { return m_toolTip; };
+
+        void ContextMenuPlacement(bool const& value) { m_useContextMenuPlacement = value; };
+        bool ContextMenuPlacement() { return m_useContextMenuPlacement; };
+
+        void ButtonStyle(AppNotificationButtonStyle const& value) { m_buttonStyle = value; };
+        AppNotificationButtonStyle ButtonStyle() { return m_buttonStyle; };
+
+        void InputId(winrt::hstring const& value) { m_inputId = value; };
+        winrt::hstring InputId() { return m_inputId; };
+
+        void InvokeUri(winrt::Windows::Foundation::Uri const& value) { m_protocolUri = value; };
+        winrt::Windows::Foundation::Uri InvokeUri() { return m_protocolUri; };
+
+        void TargetAppId(winrt::hstring const& value) { m_targetApplicationPfn = value; };
+        winrt::hstring TargetAppId() { return m_targetApplicationPfn; };
+
+        // Fluent setters
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton AddArgument(winrt::hstring const& key, winrt::hstring const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton SetIcon(winrt::Windows::Foundation::Uri const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton SetToolTip(winrt::hstring const& value);
+        static bool IsToolTipSupported();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton SetContextMenuPlacement();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton SetButtonStyle(AppNotificationButtonStyle const& value);
+        static bool IsButtonStyleSupported();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton SetInputId(winrt::hstring const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton SetInvokeUri(winrt::Windows::Foundation::Uri const& protocolUri);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationButton SetInvokeUri(winrt::Windows::Foundation::Uri const& protocolUri, winrt::hstring const& targetAppId);
+
+        winrt::hstring ToString();
+
+    private:
+        std::wstring GetActivationArguments();
+        std::wstring GetButtonStyle();
+
+        winrt::hstring m_content{};
+        winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> m_arguments { winrt::single_threaded_map<winrt::hstring, winrt::hstring>() };
+        winrt::Windows::Foundation::Uri m_iconUri{ nullptr };
+        winrt::Windows::Foundation::Uri m_protocolUri{ nullptr };
+        winrt::hstring m_targetApplicationPfn{};
+        winrt::hstring m_toolTip{};
+        winrt::hstring m_inputId{};
+        bool m_useContextMenuPlacement{};
+        AppNotificationButtonStyle m_buttonStyle { AppNotificationButtonStyle::Default };
+    };
+}
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::factory_implementation
+{
+    struct AppNotificationButton : AppNotificationButtonT<AppNotificationButton, implementation::AppNotificationButton>
+    {
+    };
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationComboBox.cpp b/dev/AppNotifications/AppNotificationBuilder/AppNotificationComboBox.cpp
new file mode 100644
index 0000000000..0004eccb6d
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationComboBox.cpp
@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "AppNotificationComboBox.h"
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationComboBox.g.cpp"
+#include "AppNotificationBuilderUtility.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    AppNotificationComboBox::AppNotificationComboBox(hstring const& id)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, id.empty(), "You must provide an id for the ComboBox");
+        m_id = EncodeXml(id).c_str();
+    };
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationComboBox AppNotificationComboBox::AddItem(winrt::hstring const& id, winrt::hstring const& content)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, m_items.Size() >= c_maxSelectionElements, "Maximum number of items added");
+        THROW_HR_IF_MSG(E_INVALIDARG, id.empty(), "You must provide an id for the item");
+
+        m_items.Insert(EncodeXml(id).c_str(), EncodeXml(content).c_str());
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationComboBox AppNotificationComboBox::SetTitle(winrt::hstring const& value)
+    {
+        m_title = EncodeXml(value).c_str();
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationComboBox AppNotificationComboBox::SetSelectedItem(winrt::hstring const& id)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, id.empty(), "You must provide an id for the selected item");
+
+        m_selectedItem = EncodeXml(id).c_str();
+
+        return *this;
+    }
+
+    std::wstring AppNotificationComboBox::GetSelectionItems()
+    {
+        std::wstring items{};
+
+        for (auto pair : m_items)
+        {
+            items.append(wil::str_printf<std::wstring>(L"<selection id='%ls' content='%ls'/>", pair.Key().c_str(), pair.Value().c_str()));
+        }
+
+        return items;
+    }
+
+    winrt::hstring AppNotificationComboBox::ToString()
+    {
+        std::wstring xmlResult{ wil::str_printf<std::wstring>(L"<input id='%ls' type='selection'%ls%ls>%ls</input>",
+            m_id.c_str(),
+            m_title.empty() ? L"" : wil::str_printf<std::wstring>(L" title='%ls'", m_title.c_str()).c_str(),
+            m_selectedItem.empty() ? L"" : wil::str_printf<std::wstring>(L" defaultInput='%ls'", m_selectedItem.c_str()).c_str(),
+            GetSelectionItems().c_str()) };
+
+        return xmlResult.c_str();
+    }
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationComboBox.h b/dev/AppNotifications/AppNotificationBuilder/AppNotificationComboBox.h
new file mode 100644
index 0000000000..38eefa4444
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationComboBox.h
@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#pragma once
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationComboBox.g.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    struct AppNotificationComboBox : AppNotificationComboBoxT<AppNotificationComboBox, winrt::Windows::Foundation::IStringable>
+    {
+        AppNotificationComboBox(winrt::hstring const& id);
+
+        // Properties
+        void Items(winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> const& value) { m_items = value; };
+        winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> Items() { return m_items; };
+
+        void Title(winrt::hstring const& value) { m_title = value; };
+        winrt::hstring Title() { return m_title; };
+
+        void SelectedItem(winrt::hstring const& value) { m_selectedItem = value; };
+        winrt::hstring SelectedItem() { return m_selectedItem; };
+
+        // Fluent Setters
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationComboBox AddItem(winrt::hstring const& id, winrt::hstring const& content);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationComboBox SetTitle(winrt::hstring const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationComboBox SetSelectedItem(winrt::hstring const& id);
+
+        // IStringable
+        winrt::hstring ToString();
+
+    private:
+        winrt::hstring m_id{};
+        winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> m_items{ winrt::single_threaded_map<winrt::hstring, winrt::hstring>() };
+        winrt::hstring m_title{};
+        winrt::hstring m_selectedItem{};
+
+        std::wstring GetSelectionItems();
+    };
+}
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::factory_implementation
+{
+    struct AppNotificationComboBox : AppNotificationComboBoxT<AppNotificationComboBox, implementation::AppNotificationComboBox>
+    {
+    };
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationProgressBar.cpp b/dev/AppNotifications/AppNotificationBuilder/AppNotificationProgressBar.cpp
new file mode 100644
index 0000000000..39002ae4ea
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationProgressBar.cpp
@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "AppNotificationProgressBar.h"
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationProgressBar.g.cpp"
+#include "AppNotificationBuilderUtility.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    AppNotificationProgressBar::AppNotificationProgressBar()
+        :m_titleBindMode{ BindMode::NotSet },
+         m_statusBindMode{ BindMode::NotSet },
+         m_valueBindMode{ BindMode::NotSet },
+         m_valueStringOverrideBindMode{ BindMode::NotSet }
+    {};
+
+    void AppNotificationProgressBar::Title(winrt::hstring const& value)
+    {
+        m_title = EncodeXml(value).c_str();
+        m_titleBindMode = BindMode::Value;
+    }
+
+    void AppNotificationProgressBar::Status(winrt::hstring const& value)
+    {
+        m_status = EncodeXml(value).c_str();
+        m_statusBindMode = BindMode::Value;
+    }
+
+    void AppNotificationProgressBar::Value(double value)
+    {
+        THROW_HR_IF_MSG(E_INVALIDARG, value < 0.0 || value > 1.0, "You must provide a value between 0.0 and 1.0");
+
+        m_value = value;
+        m_valueBindMode = BindMode::Value;
+    }
+
+    void AppNotificationProgressBar::ValueStringOverride(winrt::hstring const& value)
+    {
+        m_valueStringOverride = EncodeXml(value).c_str();
+        m_valueStringOverrideBindMode = BindMode::Value;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::SetTitle(winrt::hstring const& value)
+    {
+        Title(value);
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::BindTitle()
+    {
+        m_titleBindMode = BindMode::Bind;
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::SetStatus(winrt::hstring const& value)
+    {
+        Status(value);
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::BindStatus()
+    {
+        m_statusBindMode = BindMode::Bind;
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::SetValue(double value)
+    {
+        Value(value);
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::BindValue()
+    {
+        m_valueBindMode = BindMode::Bind;
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::SetValueStringOverride(winrt::hstring const& value)
+    {
+        ValueStringOverride(value);
+
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar AppNotificationProgressBar::BindValueStringOverride()
+    {
+        m_valueStringOverrideBindMode = BindMode::Bind;
+
+        return *this;
+    }
+
+    winrt::hstring AppNotificationProgressBar::ToString()
+    {
+        auto title{ wil::str_printf<std::wstring>(L" title='%ls'", m_titleBindMode == BindMode::Value ? m_title.c_str() : L"{progressTitle}") };
+        auto status{ wil::str_printf<std::wstring>(L" status='%ls'", m_statusBindMode == BindMode::Value ? m_status.c_str() : L"{progressStatus}") };
+        auto value{ wil::str_printf<std::wstring>(L" value='%ls'", m_valueBindMode == BindMode::Value ? wil::str_printf<std::wstring>(L"%g", m_value).c_str() : L"{progressValue}") };
+        auto valueStringOverride{ wil::str_printf < std::wstring>(L" valueStringOverride='%ls'", m_valueStringOverrideBindMode == BindMode::Value ? m_valueStringOverride.c_str() : L"{progressValueString}") };
+
+        return wil::str_printf<std::wstring>(L"<progress%ls%ls%ls%ls/>",
+            m_titleBindMode == BindMode::NotSet ? L"" :title.c_str(),
+            status.c_str(),
+            value.c_str(),
+            m_valueStringOverrideBindMode == BindMode::NotSet ? L"" : valueStringOverride.c_str()).c_str();
+    }
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationProgressBar.h b/dev/AppNotifications/AppNotificationBuilder/AppNotificationProgressBar.h
new file mode 100644
index 0000000000..49b5edf296
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationProgressBar.h
@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#pragma once
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationProgressBar.g.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+
+    struct AppNotificationProgressBar : AppNotificationProgressBarT<AppNotificationProgressBar, winrt::Windows::Foundation::IStringable>
+    {
+        AppNotificationProgressBar();
+
+        // Properties
+        void Title(winrt::hstring const& value);
+        winrt::hstring Title() { return m_title; };
+
+        void Status(winrt::hstring const& value);
+        winrt::hstring Status() { return m_status; };
+
+        void Value(double value);
+        double Value() { return m_value; };
+
+        void ValueStringOverride(winrt::hstring const& value);
+        winrt::hstring ValueStringOverride() { return m_valueStringOverride; };
+
+        // Fluent setters
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar SetTitle(winrt::hstring const& value);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar BindTitle();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar SetStatus(winrt::hstring const& value);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar BindStatus();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar SetValue(double value);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar BindValue();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar SetValueStringOverride(winrt::hstring const& value);
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationProgressBar BindValueStringOverride();
+
+        // IStringable
+        winrt::hstring ToString();
+
+    private:
+        enum class BindMode {NotSet, Bind, Value};
+
+        BindMode m_titleBindMode;
+        winrt::hstring m_title;
+        BindMode m_statusBindMode;
+        winrt::hstring m_status;
+        BindMode m_valueBindMode;
+        double m_value;
+        BindMode m_valueStringOverrideBindMode;
+        winrt::hstring m_valueStringOverride;
+    };
+}
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::factory_implementation
+{
+    struct AppNotificationProgressBar : AppNotificationProgressBarT<AppNotificationProgressBar, implementation::AppNotificationProgressBar>
+    {
+    };
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationTextProperties.cpp b/dev/AppNotifications/AppNotificationBuilder/AppNotificationTextProperties.cpp
new file mode 100644
index 0000000000..15cecdc93e
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationTextProperties.cpp
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "AppNotificationTextProperties.h"
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationTextProperties.g.cpp"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationTextProperties AppNotificationTextProperties::SetLanguage(winrt::hstring const& value)
+    {
+        m_language = value;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationTextProperties AppNotificationTextProperties::SetIncomingCallAlignment()
+    {
+        m_useCallScenarioAlign = true;
+        return *this;
+    }
+
+    winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationTextProperties AppNotificationTextProperties::SetMaxLines(int const& value)
+    {
+        m_maxLines = value;
+        return *this;
+    }
+
+    winrt::hstring AppNotificationTextProperties::ToString()
+    {
+        std::wstring language{ !m_language.empty() ? wil::str_printf<std::wstring>(L" lang='%ls'", m_language.c_str()) : L""};
+        std::wstring callScenarioAlign{ m_useCallScenarioAlign ? L" hint-callScenarioCenterAlign='true'" : L""};
+        std::wstring hintMaxLines{ m_maxLines ? wil::str_printf<std::wstring>(L" hint-maxLines='%d'", m_maxLines) : L"" };
+
+        return wil::str_printf<std::wstring>(L"<text%ls%ls%ls>", language.c_str(), hintMaxLines.c_str(), callScenarioAlign.c_str()).c_str();
+    }
+}
diff --git a/dev/AppNotifications/AppNotificationBuilder/AppNotificationTextProperties.h b/dev/AppNotifications/AppNotificationBuilder/AppNotificationTextProperties.h
new file mode 100644
index 0000000000..547edfca0d
--- /dev/null
+++ b/dev/AppNotifications/AppNotificationBuilder/AppNotificationTextProperties.h
@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#pragma once
+#include "Microsoft.Windows.AppNotifications.Builder.AppNotificationTextProperties.g.h"
+
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::implementation
+{
+    struct AppNotificationTextProperties : AppNotificationTextPropertiesT<AppNotificationTextProperties, winrt::Windows::Foundation::IStringable>
+    {
+        AppNotificationTextProperties() = default;
+
+        // Properties
+        void Language(winrt::hstring const& value) { m_language = value; };
+        winrt::hstring Language() { return m_language; };
+
+        void MaxLines(int const& value) { m_maxLines = value; };
+        int MaxLines() { return m_maxLines; };
+
+        void IncomingCallAlignment(bool const& value) { m_useCallScenarioAlign = value; };
+        bool IncomingCallAlignment() { return m_useCallScenarioAlign; };
+
+        // Fluent Setters
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationTextProperties SetLanguage(winrt::hstring const& value);
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationTextProperties SetIncomingCallAlignment();
+
+        winrt::Microsoft::Windows::AppNotifications::Builder::AppNotificationTextProperties SetMaxLines(int const& value);
+
+        // IStringable
+        winrt::hstring ToString();
+
+    private:
+        int m_maxLines{ 0 };
+        winrt::hstring m_language{};
+        bool m_useCallScenarioAlign{};
+    };
+}
+namespace winrt::Microsoft::Windows::AppNotifications::Builder::factory_implementation
+{
+    struct AppNotificationTextProperties : AppNotificationTextPropertiesT<AppNotificationTextProperties, implementation::AppNotificationTextProperties>
+    {
+    };
+}
diff --git a/dev/AppNotifications/AppNotifications.idl b/dev/AppNotifications/AppNotifications.idl
index 11cea33beb..3b439b8ac9 100644
--- a/dev/AppNotifications/AppNotifications.idl
+++ b/dev/AppNotifications/AppNotifications.idl
@@ -4,7 +4,7 @@ import "..\AppLifecycle\AppLifecycle.idl";
 
 namespace Microsoft.Windows.AppNotifications
 {
-    [contractversion(2)]
+    [contractversion(3)]
     apicontract AppNotificationsContract {}
 
     // Event args for the Notification Activation
@@ -16,6 +16,10 @@ namespace Microsoft.Windows.AppNotifications
 
         // The data from the input elements of a Notification like a TextBox
         Windows.Foundation.Collections.IMap<String, String> UserInput{ get; };
+
+        // Arguments from the invoked button built from AppNotificationBuilder
+        [contract(AppNotificationsContract, 3)]
+        Windows.Foundation.Collections.IMap<String, String> Arguments{ get; };
     }
 
     // Notification Progress Data
diff --git a/dev/AppNotifications/AppNotifications.vcxitems b/dev/AppNotifications/AppNotifications.vcxitems
index 63b054a559..72a89d2640 100644
--- a/dev/AppNotifications/AppNotifications.vcxitems
+++ b/dev/AppNotifications/AppNotifications.vcxitems
@@ -26,6 +26,7 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)ShellLocalization.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationActivatedEventArgs.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationManager.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)AppNotification.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)AppNotificationProgressData.cpp" />
diff --git a/dev/WindowsAppRuntime_DLL/WindowsAppRuntime_DLL.vcxproj b/dev/WindowsAppRuntime_DLL/WindowsAppRuntime_DLL.vcxproj
index f0b3c49e30..f3e1741b3c 100644
--- a/dev/WindowsAppRuntime_DLL/WindowsAppRuntime_DLL.vcxproj
+++ b/dev/WindowsAppRuntime_DLL/WindowsAppRuntime_DLL.vcxproj
@@ -87,6 +87,7 @@
     <Import Project="..\AppLifecycle\AppLifecycle.vcxitems" Label="AppLifecycle" />
     <Import Project="..\PushNotifications\PushNotifications.vcxitems" Label="PushNotifications" />
     <Import Project="..\AppNotifications\AppNotifications.vcxitems" Label="AppNotifications" />
+    <Import Project="..\AppNotifications\AppNotificationBuilder\AppNotificationBuilder.vcxitems" Label="AppNotificationBuilder" />
     <Import Project="..\DynamicDependency\API\DynamicDependency.vcxitems" Label="Shared" />
     <Import Project="..\UndockedRegFreeWinRT\UndockedRegFreeWinRT.vcxitems" Label="Shared" />
     <Import Project="..\Common\Common.vcxitems" Label="Shared" />
diff --git a/specs/AppNotifications/AppNotificationContentSpec/AppLogoOverrideImageExample.png b/specs/AppNotifications/AppNotificationContentSpec/AppLogoOverrideImageExample.png
new file mode 100644
index 0000000000..65c0aeb26d
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/AppLogoOverrideImageExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/AppNotificationBuilder-spec.md b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationBuilder-spec.md
new file mode 100644
index 0000000000..3769e71334
--- /dev/null
+++ b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationBuilder-spec.md
@@ -0,0 +1,1227 @@
+# App Notification Content Builder
+
+# Background
+
+App Notifications are UI popups that contain rich text, controls and images to display a message to
+the user. With the Windows App SDK, developers can define an XML payload and display an
+AppNotification using the AppNotificationManager::Show API, but defining these XML payloads can be
+tedious when written by hand.
+
+To generate an AppNotification like this one:
+
+![App Notification With Avatar Image](AppNotificationWithAvatarImage.png)
+
+Developers have to write something like this:
+
+```c++
+int sequenceId {1234};
+std::wstring pathToImage {LR"(ms-appx://images/appLogo.png)"};
+
+winrt::hstring xmlPayload{
+    fmt::format(LR"(<toast launch = "action=AppNotificationClick;sequence={}">
+        <visual>
+            <binding template="ToastGeneric">
+                <image placement="appLogoOverride" hint-crop="circle" src="{}"/>
+                <text>App Notification with Avatar Image</text>
+                <text>This is an example message using XML</text>
+            </binding>
+        </visual>
+        <actions>
+            <action
+                content="Open App"
+                arguments="action=OpenApp&amp;sequence={}">
+        </actions>
+    </toast>)" ,
+    sequenceId, pathToImage, sequenceId)};
+auto appNotification{ winrt::AppNotification(xmlPayload) };
+winrt::AppNotificationManager::Default().Show(appNotification);
+```
+
+# Description
+
+To improve the AppNotification construction experience, the Windows App SDK is introducing
+AppNotificationBuilder, a builder that constructs simple or rich App Notifications for the
+developer.
+
+```c++
+AppNotificationBuilder()
+    .AddArgument(L"AppNotificationClick")
+    .AddArgument(L"sequence", winrt::to_hstring(sequenceId))
+    .SetAppLogoOverride(winrt::Windows::Foundation::Uri(pathToImage), AppNotificationImageCrop::Circle)
+    .AddText(L"App Notification with Avatar Image")
+    .AddText(L"This is an example message")
+    .AddButton(AppNotificationButton(L"Open App")
+        .AddArgument(L"action", L"OpenAppButton")
+        .AddArgument(L"sequence", winrt::to_hstring(sequenceId)));
+```
+
+# API Components
+
+# AppNotificationBuilder
+
+The AppNotificationBuilder component sets up the xml for a `<toast>`. This is the wrapper content
+that will include any component adding to the AppNotification UI.
+
+### WinAppSDK 1.2 `<toast>` Schema
+
+```xml
+<toast
+    launch? = string
+    duration? = "long" | "short"
+    displayTimeStamp? = string
+    scenario? = "reminder" | "alarm" | "incomingCall" | "urgent"
+    useButtonStyle? = boolean>
+      <!-- Child elements -->
+    visual, audio?, actions?
+</toast>
+```
+
+These attributes are abstracted away by the following AppNotificationBuilder component APIs
+available in the Windows App SDK:
+
+-   AppNotificationBuilder();
+-   AddArgument(String key, String value)
+-   SetTimeStamp(Windows.Foundation.DateTime dateTime)
+-   SetScenario(AppNotificationScenario Scenario)
+    -   AppNotificationScenario.Reminder
+    -   AppNotificationScenario.Alarm
+    -   AppNotificationScenario.IncomingCall
+    -   AppNotificationScenario.Urgent
+
+useButtonStyle will only be set if AppNotificationButton::SetButtonStyle is used.
+
+You can append UI components through the AppNotificationBuilder component APIs:
+
+-   AddText
+-   AddButton
+-   SetInlineImage
+-   SetAppLogoOverrideImage
+-   SetHeroImage
+-   SetAudioUri
+-   SetAudioEvent
+-   AddTextBox
+-   AddComboBox
+
+The main advantage as an API is to provide validation, type safety, and foremost intellisense.
+
+Below is an example usage:
+
+![AppNotification Example](AppNotificationExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddArgument(L"action", L"openThread")
+    .AddArgument(L"threadId", L"92187")
+    .SetTimeStamp(DateTime.now())
+    .AddText(L"Jill Bender", AppNotificationTextProperties().SetMaxLines(1))
+    .AddText(L"Checkout where we camped last weekend")
+    .SetAppLogoOverride(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/appLogo.png)"), AppNotificationImageCrop::Circle)
+    .SetHeroImage(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/heroImage.png)"))
+    .AddTextBox(L"textBox", L"reply")
+    .AddButton(AppNotificationButton()
+        .AddArgument(L"action", L"reply")
+        .AddArgument(L"threadId", L"92187")
+        .SetIcon(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/Icon.png)"))
+        .SetInputId(L"textBox"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast launch="action=openThread&amp;threadId=92187" displayTimestamp="2022-06-19T08:30:00Z">
+    <visual>
+        <binding template="ToastGeneric">
+            <text hint-maxLines="1">Jill Bender</text>
+            <text>Check out where we camped last weekend! It was incredible, wish you could have come on the backpacking trip!</text>
+            <image placement="appLogoOverride" hint-crop="circle" src="ms-appx://images/appLogo.png"/>
+            <image placement="hero" src="ms-appx://images/heroImage.png"/>
+        </binding>
+    </visual>
+    <actions>
+        <input id="textBox" type="text" placeHolderContent="reply"/>
+        <action
+          content="Send"
+          imageUri="ms-appx://images/Icon.png"
+          hint-inputId="textBox"
+          arguments="action=reply&amp;threadId=92187"/>
+    </actions>
+</toast>
+```
+
+## Limitations
+
+-   AppNotificationScenario.Urgent is only supported for to builds 19041 (20H1) and above. Using
+    this attribute on lower builds will not prevent the AppNotification from being constructed, but
+    developers can use AppNotificationBuilder.IsUrgentScenarioSupported to check if the feature is
+    available at runtime.
+
+# Text
+
+The Text component sets up the xml for a `<text>` element. Developers can define the content,
+language, and placement of the text on the AppNotification.
+
+**WinAppSDK 1.2 \<text\> Schema**:
+
+```xml
+<text lang? = string
+      placement? = "attribution"
+      hint-callScenarioCenterAlign? =
+      hint-maxLines? = integer />
+```
+
+These attributes are abstracted with the following AppNotificationTextProperties component APIs
+available in the Windows App SDK:
+
+-   SetLanguage(String language)
+-   SetHintMaxLines(Int32)
+-   SetIncomingCallAlignment()
+
+Below are some example usages:
+
+![Text Example](TextExample.png)
+
+AppNotificationBuilder Code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Content")
+    .SetAttributionText(L"Attribution Text")
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>Content</text>
+      <text placement="attribution">Attribution Text</text>
+    </binding>
+  </visual>
+</toast>
+```
+
+Developers can use SetIncomingCallAlignment() to center the text like an incoming call. This feature
+will be ignored unless the AppNotification scenario is set to IncomingCall using
+AppNotificationBuilder::SetScenario(enum AppNotificationScenario).
+
+![IncomingCall Simple Example](IncomingCallSimpleExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .SetScenario(AppNotificationScenario::IncomingCall)
+    .AddText(L"Incoming Call", AppNotificationTextProperties()
+        .SetIncomingCallAlignment())
+    .AddText(L"Andrew Barnes", AppNotificationTextProperties()
+        .SetIncomingCallAlignment())
+    .SetInlineImage(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/inlineImage.png)"), AppNotificationImageCrop::Circle)
+    .AddButton(AppNotificationButton()
+        .SetIcon(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/icon.png)"))
+        .SetButtonStyle(AppNotificationButtonStyle::Success)
+        .SetToolTip(L"Answer video call"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast scenario="incomingCall" useButtonStyle="true">
+    <visual>
+        <binding template="ToastGeneric">
+            <text hint-callScenarioCenterAlign = "true">Incoming Call</text>
+            <text hint-callScenarioCenterAlign = "true">Andrew Barnes</text>
+            <image hint-crop="circle"  src="ms-appx://images/inlineImage.png"/>
+        </binding>
+    </visual>
+
+    <actions>
+        <action
+              arguments="videoCallId"
+              content=""
+              imageUri="ms-appx://images/icon.png"
+              hint-buttonStyle = "Success"
+              hint-toolTip = "Answer video call"/>
+</toast>
+```
+
+Notice that the text is inserted into the xml the order that it was provided in the builder.
+
+# AppNotificationButton
+
+The AppNotificationButton component API sets up the xml for the `<action>` element.
+AppNotificationButtons are user-clickable components meant to start an action from the app.
+
+**WinAppSDK 1.2 \<action\> Schema**:
+
+```xml
+<action content = string
+        arguments = string
+        placement? = "contextMenu"
+        imageUri? = string
+        hint-inputid? = string
+        hint-buttonStyle? = "success" | "critical"
+        hint-toolTip? = string />
+```
+
+These attributes are abstracted with the following AppNotificationButton component APIs available in
+the Windows App SDK:
+
+-   AppNotificationButton()
+-   AppNotificationButton(String content)
+-   SetIcon(Windows.Foundation.Uri iconUri)
+-   SetToolTip(String toolTip)
+-   SetContextMenuPlacement()
+-   SetInputId(String inputId)
+
+Below are some example usages:
+
+![Button Example](ButtonExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Content")
+    .AddTextBox(L"textBox", L"Reply")
+    .AddButton(AppNotificationButton(L"Send")
+        .AddArgument(L"action", L"textReply")
+        .SetIcon(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/icon.png)"))
+        .SetInputId(L"textBox"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>Content</text>
+    </binding>
+  </visual>
+
+    <actions>
+        <input id="textBox" type="text" placeHolderContent="Reply"/>
+        <action
+          content="Send"
+          imageUri="ms-appx://images/icon.png"
+          hint-inputId="textBox"
+          arguments="action=textReply"/>
+    </actions>
+</toast>
+```
+
+Developers can change the button style of the button using
+SetButtonStyle(AppNotificationButtonStyle). The two button styles are
+AppNotificationButtonStyle.Success and AppNotificationButtonStyle.Critical.
+
+![Button Style Example](IncomingCallExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .SetScenario(AppNotificationScenario::IncomingCall)
+    .AddText(L"Incoming Call", AppNotificationTextProperties()
+        .SetIncomingCallAlignment())
+    .AddText(L"Andrew Barnes", AppNotificationTextProperties()
+        .SetIncomingCallAlignment())
+    .SetInlineImage(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/inlineImage.png)"), AppNotificationImageCrop::Circle)
+    .AddButton(AppNotificationButton()
+        .AddArgument(L"videoCall", L"938465")
+        .SetIcon(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/videoCall.png)"))
+        .SetButtonStyle(AppNotificationButtonStyle::Success)
+        .SetToolTip(L"Answer video call"))
+    .AddButton(AppNotificationButton()
+        .AddArgument(L"voiceCall", L"938465")
+        .SetIcon(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/voiceCall.png)"))
+        .SetButtonStyle(AppNotificationButtonStyle::Success)
+        .SetToolTip(L"Answer voice call"))
+    .AddButton(AppNotificationButton()
+        .AddArgument(L"declineCall", L"938465")
+        .SetIcon(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/declineCall.png)"))
+        .SetButtonStyle(AppNotificationButtonStyle::Critical)
+        .SetToolTip(L"Decline all"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast scenario="incomingCall" useButtonStyle="true">
+    <visual>
+        <binding template="ToastGeneric">
+            <text hint-callScenarioCenterAlign = "true">Incoming Call</text>
+            <text hint-callScenarioCenterAlign = "true">Andrew Barnes</text>
+            <image hint-crop="circle"  src="ms-appx://images/inlineImage.png"/>
+        </binding>
+    </visual>
+
+    <actions>
+        <action
+              arguments="videoCall=938465;action=accept"
+              content=""
+              imageUri="ms-appx://images/videoCall.png"
+              hint-buttonStyle = "Success"
+              hint-toolTip = "Answer video call"/>
+        <action
+              arguments="voiceCall=938465"
+              content=""
+              imageUri="ms-appx://images/voiceCall.png"
+              hint-buttonStyle = "Success"
+              hint-toolTip = "Answer voice call"/>
+        <action
+              arguments="declineCall=938465"
+              content=""
+              imageUri="ms-appx://images/declineCall.png"
+              hint-buttonStyle = "Critical"
+              hint-toolTip = "Decline all"/>
+      </actions>
+</toast>
+```
+
+Notice that the AppNotificationButtons are inserted into the xml the order that it was provided in
+the builder.
+
+The ToolTip is useful for buttons with icons and no content. Users can hover over the button with
+the cursor and a text will display describing what the button does.
+
+![Button ToolTip Example](ButtonToolTipExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Content")
+    .AddTextBox(L"textBox", L"Reply")
+    .AddButton(AppNotificationButton()
+        .AddArgument(L"action", L"textReply")
+        .SetInputId(L"textBox")
+        .SetToolTip(L"Send")
+        .SetIcon(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/icon.png)")))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>Content</text>
+    </binding>
+  </visual>
+
+    <actions>
+            <input id="textBox" type="text" placeHolderContent="Reply"/>
+            <action
+            content=""
+            imageUri="ms-appx://images/icon.png"
+            hint-inputId="textBox"
+            hint-toolTip="Send"
+            arguments="action=textReply"/>
+    </actions>
+</toast>
+```
+
+The context menu is a popup UI that appears when the user right clicks on the AppNotification. The
+default options are to turn off receiving notifications for the application and to launch the
+notification settings page. Using SetContextMenuPlacement() will add an option to the context menu.
+The behavior is the same as other buttons and when activated returns the arguments to the app.
+
+![Button ContextMenu Example](ButtonContextMenuExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Content")
+    .AddTextBox(L"textBox", L"Reply")
+    .AddButton(AppNotificationButton(L"Modify app settings")
+        .AddArgument(L"action", L"textReply")
+        .SetContextMenuPlacement())
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>Content</text>
+    </binding>
+  </visual>
+
+    <actions>
+            <input id="textBox" type="text" placeHolderContent="Reply"/>
+            <action
+            placement="contextMenu"
+            content="Modify app settings"
+            arguments="action=textReply"/>
+    </actions>
+</toast>
+```
+
+## Limitations
+
+-   hint-toolTip and hint-buttonStyle are only supported for builds 19041 (20H1) and above. Using
+    these attributes on lower builds will not prevent the AppNotification from being constructed,
+    but developers can use AppNotificationButton.IsButtonStyleSupported and
+    AppNotificationButton.IsToolTipSupported to check if the feature is available at runtime.
+
+# Image
+
+The Image component API sets up the xml for the `<image>` element. Images are visual elements that
+are used to enhance an AppNotification.
+
+The image source can be specified using one of these protocol handlers:
+
+-   http:// or https:// (A web-based image) (unavailable for unpackaged application on build 22000)
+-   ms-appx:/// (An image included in the app package) (only for packaged applications)
+-   ms-appdata:///local/ (An image saved to local storage) (only for packaged applications)
+-   file:/// (A local image) (only for unpackaged)
+
+**WinAppSDK 1.2 \<image\> Schema**:
+
+```xml
+<image src = string
+       alt? = string
+       placement? = "appLogoOverride" | "hero"
+       hint-crop? = "circle" />
+```
+
+Images can be displayed in three different ways:
+
+## Inline
+
+A full-width inline-image that appears when you expand the AppNotification.
+
+![Inline Image Example](InlineImageExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Below is an inline image")
+    .SetInlineImage(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/inlineImage.png)"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>Below is an inline image</text>
+      <image src="ms-appx://images/inlineImage.png">
+    </binding>
+  </visual>
+</toast>
+```
+
+## AppLogoOverride
+
+The image replaces your app's logo in the AppNotification.
+
+![AppLogoOverride Image Example](AppLogoOverrideImageExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"To the left is an AppLogoOverride")
+    .SetAppLogoOverride(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/appLogo.png)"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>To the left is an AppLogoOverride</text>
+      <image src="ms-appx://images/appLogo.png"
+                placement="appLogoOverride" />
+    </binding>
+  </visual>
+</toast>
+```
+
+## Hero
+
+Prominently displays image within the AppNotification banner and while inside Notification Center.
+
+![Hero Image Example](HeroImageExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Above is a Hero image")
+    .SetHeroImage(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/heroImage.png)"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>Above is a Hero image</text>
+      <image src="ms-appx://images/heroImage.png"
+                placement="hero" />
+    </binding>
+  </visual>
+</toast>
+```
+
+## Cropped AppLogoOverride
+
+For both Inline and AppLogoOverride, developers can set how the image will be cropped.
+
+![Cropped AppLogoOverride Image Example](CroppedAppLogoOverrideExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"To the left is a cropped AppLogoOverride")
+    .SetAppLogoOverride(winrt::Windows::Foundation::Uri(LR"(ms-appx://images/appLogo.png)"), AppNotificationImageCrop::Circle);
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>To the left is a cropped AppLogoOverride</text>
+      <image src="ms-appx://images/appLogo.png"
+                hint-crop="circle"
+                placement="appLogoOverride" />
+    </binding>
+  </visual>
+</toast>
+```
+
+Supported image file types include:
+
+-   .png
+-   .jpg
+-   .svg
+
+# Audio
+
+The Audio component allows the developer to define a custom audio to play when an AppNotification is
+displayed. The audio file can be defined by string value pointing to an app asset or one of the
+[ms-winsoundevents](https://docs.microsoft.com/uwp/schemas/tiles/toastschema/element-audio).
+
+**WinAppSDK 1.2 `<audio>` Schema**:
+
+```xml
+<audio src? = string
+       loop? = boolean
+       silent? = boolean />
+```
+
+These attributes are abstracted with the following Audio component APIs available in the Windows App
+SDK:
+
+-   SetAudioUri(Windows.Foundation.Uri)
+-   SetAudioUri(Windows.Foundation.Uri, AppNotificationAudioLooping)
+-   SetAudioEvent(AppNotificationSoundEvent)
+-   SetAudioEvent(AppNotificationSoundEvent, AppNotificationAudioLooping)
+-   MuteAudio()
+
+Supported audio file types include:
+
+-   .aac
+-   .flac
+-   .m4a
+-   .mp3
+-   .wav
+-   .wma
+
+Supported audio file sources:
+
+-   ms-appx:///
+-   ms-resource
+
+Not supported audio file sources:
+
+-   ms-appdata
+-   http://, https://
+-   C:/, F:/, etc.
+
+More information on custom audio can be found
+[here](https://docs.microsoft.com/en-us/windows/apps/design/shell/tiles-and-notifications/custom-audio-on-toasts).
+
+Below are some example usages:
+
+```cpp
+AppNotificationBuilder()
+    .SetAudioEvent(AppNotificationSoundEvent::Reminder)
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+    </binding>
+  </visual>
+  <audio src="ms-winsoundevent:Notification.Reminder" />
+</toast>
+```
+
+Developers can define if the audio should be looped using SetAudioUri(Uri,
+AppNotificationAudioLooping), which can be default or long.
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Content")
+    .SetAudioEvent(AppNotificationSoundEvent::Alarm, AppNotificationAudioLooping::Loop)
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast duration="long">
+  <visual>
+    <binding template="ToastGeneric">
+        <text>Above is a Hero image</text>
+    </binding>
+  </visual>
+  <audio src="ms-winsoundevent:Notification.Looping.Alarm" loop="true" />
+</toast>
+```
+
+An AppNotification that does not want to play any audio can use MuteAudio to mute the audio.
+
+```cpp
+AppNotificationBuilder()
+    .AddText(L"Content")
+    .MuteAudio()
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast duration="long">
+  <visual>
+    <binding template="ToastGeneric">
+        <text>Content</text>
+    </binding>
+  </visual>
+  <audio silent="true" />
+</toast>
+```
+
+# TextBox
+
+TextBox is an `<input>` component that allows users to type custom responses on an AppNotification.
+
+**WinAppSDK 1.2 TextBox Schema**:
+
+```xml
+<input id = string
+        type="text"
+        placeHolderContent? = string>
+</input>
+```
+
+These attributes are abstracted with the following TextBox component APIs available in the Windows
+App SDK:
+
+-   TextBox(String id)
+-   TextBox(String id, String placeHolderContent)
+
+Below is an example use:
+
+![TextBox Example](TextBoxExample.png)
+
+AppNotificationBuilder code:
+
+```cpp
+AppNotificationBuilder()
+    .AddTextBox(L"textBox", L"reply")
+    .AddButton(AppNotificationButton(L"Send")
+        .AddArguments(L"action", L"Send")
+        .SetInputId(L"textBox"))
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+    </binding>
+  </visual>
+
+  <actions>
+    <input id="textBox" type="text" />
+    <action
+      arguments="action=Send"
+      content="Send"
+      hint-inputId="textBox" />
+  </actions>
+</toast>
+```
+
+You can have up to 5 input components (TextBox/AppNotificationComboBox) total in the builder. The
+order in the result xml will be the order it was added to the builder.
+
+# AppNotificationComboBox
+
+AppNotificationComboBox is an `<input>` component that allows users to pick from a dropdown menu of
+values on an AppNotification.
+
+**WinAppSDK 1.2 AppNotificationComboBox Schema**:
+
+```xml
+<input id = string
+        type="selection"
+        defaultInput? = string>
+    <!-- Child elements -->
+    selection{0,5}
+</input>
+```
+
+These attributes are abstracted with the following AppNotificationComboBox component APIs available
+in the Windows App SDK:
+
+-   AppNotificationComboBox(String id)
+-   SetDefaultSelection(String id)
+-   AddSelection(String id, String content)
+
+Below is an example use:
+
+![ComboBox Example](ComboBoxExample.png)
+
+```cpp
+AppNotificationBuilder()
+    .AddComboBox(AppNotificationComboBox(L"ComboBox")
+        .SetDefaultSelection(L"yes")
+        .AddSelection(L"yes", L"Going")
+        .AddSelection(L"maybe", L"Maybe")
+        .AddSelection(L"no", L"Decline"))
+    .AddButton(AppNotificationButton(L"Send")
+        .AddArgument(L"action", L"Send"))
+        .SetInputId(L"ComboBox")
+    .BuildNotification();
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+    </binding>
+  </visual>
+
+  <actions>
+    <input id="ComboBox" type="selection" defaultInput="yes">
+      <selection id="yes" content="Going" />
+      <selection id="maybe" content="Maybe" />
+      <selection id="no" content="Decline" />
+    </input>
+    <action
+      arguments="action=Send"
+      hint-inputId="ComboBox"
+      content="Send"/>
+
+  </actions>
+</toast>
+```
+
+# AppNotificationProgressBar
+
+AppNotificationProgressBar is a component that builds the `<progress>` xml.
+AppNotificationProgressBar is used to update an AppNotification that is currently displayed. This
+allows developers to inform users about the status of certain operations such as download or
+install.
+
+**WinAppSDK 1.2 `<progress>` Schema**:
+
+```xml
+<progress title? = string
+    status = string
+    value = string
+    valueStringOverride? = string
+/>
+```
+
+AppNotificationProgressBar uses data binding to update the active UI. In the WindowsAppSDK, this is
+done by using AppNotificationProgressData. Click
+[Here](https://github.com/microsoft/WindowsAppSDK/blob/main/specs/AppNotifications/AppNotifications-spec.md#notification-progress-updates)
+for an example.
+
+All the attributes have static data binding constants:
+
+-   Status = "{progressStatus}"
+-   Value = "{progressValue}"
+-   Title = "{progressTitle}"
+-   ValueStringOverride = "{progressValueString}
+
+By default, status and value use data binding, but you can explicitly bind values of the progress
+bar:
+
+-   BindStatus()
+-   BindValue()
+-   BindTitle()
+-   BindValueStringOverride()
+
+You can also set static values of the progress bar by passing in specific values:
+
+-   SetStatus(String status)
+-   SetValue(Double value)
+-   SetTitle(String title)
+-   SetValueStringOverride(String valueStringOverride)
+
+Below is an example use:
+
+```cpp
+// Using AppNotificationBuilder, build the AppNotification with AppNotificationProgressBar as the xmlPayload.
+AppNotification notification { AppNotificationBuilder()
+    .AddText(L"Downloading this week's new music...")
+    .AddProgressBar(AppNotificationProgressBar()
+        .BindTitle()
+        .BindValueStringOverride())
+    .SetTag(L"Tag")
+    .SetGroup(L"Group")
+    .BuildNotification() };
+```
+
+XML payload:
+
+```xml
+<toast>
+  <visual>
+    <binding template="ToastGeneric">
+      <text>Downloading this week's new music...</text>
+      <progress
+        title="{progressTitle}"
+        value="{progressValue}"
+        valueStringOverride="{progressValueString}"
+        status="{progressStatus}"/>
+    </binding>
+  </visual>
+</toast>
+```
+
+Assign initial values for first notification progress UI:
+
+```cpp
+winrt::Microsoft::Windows::AppNotifications::AppNotificationProgressData data(1 /* Sequence number */);
+data.Title(L"Katy Perry"); // Binds to {progressTitle} in xml payload
+data.Value(0.5); // Binds to {progressValue} in xml payload
+data.ValueStringOverride(L"1/2 songs"); // Binds to {progressValueString} in xml payload
+data.Status(L"Downloading..."); // Binds to {progressStatus} in xml payload
+
+notification.Progress(data); // Updates the AppNotification values
+winrt::AppNotificationManager::Default().Show(notification);
+```
+
+![Progress Bar Example 1](ProgressBarExample1.png)
+
+Then update the AppNotificationProgressBar using AppNotificationProgressData:
+
+```cpp
+data.SequenceNumber(2);
+data.Title(L"Katy Perry"); // Binds to {progressTitle} in xml payload
+data.Value(1.0); // Binds to {progressValue} in xml payload
+data.ValueStringOverride(L"2/2 songs"); // Binds to {progressValueString} in xml payload
+data.Status(L"Finished!"); // Binds to {progressStatus} in xml payload
+
+auto result = co_await winrt::Microsoft::Windows::AppNotifications::AppNotificationManager::Default().UpdateAsync(data, L"Tag", L"Group");
+```
+
+![Progress Bar Example 2](ProgressBarExample2.png)
+
+# Retrieving Arguments
+
+AppNotificationBuilder and Button return arguments to the activated application when the user clicks
+on the component. Developers can add multiple key/value pairs and Windows App SDK will serialize
+them into a string.
+
+Below is an example with AppNotificationBuilder and Button:
+
+```cpp
+AppNotificationBuilder()
+    .AddArgument(L"action", L"appNotificationBodyTouch")
+    .AddArgument(L"user", L"938163")
+    .AddButton(AppNotificationButton(L"Send")
+        .AddArgument(L"action", L"buttonTouch")
+        .AddArgument(L"user", L"938163"));
+```
+
+When the user clicks on the AppNotification body, the resulting argument string is:
+
+-   "action=appNotificationBodyTouch;user=938163"
+
+When the user clicks on the Button, the result argument string is:
+
+-   "action=buttonTouch;callId=938163"
+
+Notice that ';' is used as the delimiter between each argument. The library will escape the ';' if
+it exists as a character in the argument. The ';' will then be unescaped when the arguments are
+retrieved from AppNotificationActivatedEventArgs::Arguments.
+
+To retrieve the arguments from the serialized string, developers will use
+AppNotificationReceivedEventArgs::Arguments to get the values from the argument string as a map.
+
+Below is an example usage:
+
+```cpp
+using namespace winrt::Microsoft::Windows::AppLifecycle;
+using namespace winrt::Microsoft::Windows::AppNotifications;
+
+// Retrieve the activation args using Windows App SDK AppLifecycle functions
+AppActivationArguments args { AppLifecycle::AppInstance::GetCurrent().GetActivatedEventArgs() };
+ExtendedActivationKind kind { args.Kind() };
+
+// Check the activation kind
+if (kind == ExtendedActivationKind::AppNotification)
+{
+    AppNotificationActivatedEventArgs appActivatedArgs { args.Data().as<AppNotificationActivatedEventArgs>() };
+
+    // Retrieve the serialized arguments from AppNotificationActivatedEventArgs
+    winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> argumentMap { appActivatedArgs.Argument() };
+}
+```
+
+# Full API Details
+
+```cpp
+namespace Microsoft.Windows.AppNotifications.Builder
+{
+    runtimeclass AppNotificationTextProperties
+    {
+        AppNotificationTextProperties();
+
+        String Language;
+        Boolean IncomingCallAlignment;
+        Int32 MaxLines;
+
+        AppNotificationTextProperties SetLanguage(String value);
+        AppNotificationTextProperties SetIncomingCallAlignment();
+        AppNotificationTextProperties SetMaxLines(Int32 value);
+    }
+
+    enum AppNotificationButtonStyle
+    {
+        Default,
+        Success,
+        Critical,
+    };
+
+    runtimeclass AppNotificationButton
+    {
+        AppNotificationButton();
+        AppNotificationButton(String content);
+
+        String Content;
+        Windows.Foundation.Collections.IMap<String, String> Arguments;
+        Windows.Foundation.Uri Icon;
+        String ToolTip;
+        Boolean ContextMenuPlacement;
+        AppNotificationButtonStyle ButtonStyle;
+        String InputId;
+        Windows.Foundation.Uri InvokeUri;
+        String TargetAppId;
+
+        AppNotificationButton AddArgument(String key, String value);
+
+        AppNotificationButton SetIcon(Windows.Foundation.Uri value);
+
+        AppNotificationButton SetToolTip(String value);
+        static Boolean IsToolTipSupported();
+
+        AppNotificationButton SetContextMenuPlacement();
+
+        AppNotificationButton SetButtonStyle(AppNotificationButtonStyle value);
+        static Boolean IsButtonStyleSupported();
+
+        // Specifies the ID of an existing TextBox next to which the button will be placed.
+        AppNotificationButton SetInputId(String value);
+
+        // Launches the URI passed into the button when activated.
+        AppNotificationButton SetInvokeUri(Windows.Foundation.Uri protocolUri);
+        AppNotificationButton SetInvokeUri(Windows.Foundation.Uri protocolUri, String targetAppId);
+
+    };
+
+    runtimeclass AppNotificationComboBox
+    {
+        AppNotificationComboBox(String id);
+
+        Windows.Foundation.Collections.IMap<String, String> Items;
+        String Title;
+        String SelectedItem;
+
+        // Add a selection to the AppNotificationComboBox. The id parameter identifies the item the user selected.
+        AppNotificationComboBox AddItem(String id, String content);
+
+        // Adds a title to display on top
+        AppNotificationComboBox SetTitle(String value);
+
+        // Sets the default selection to be displayed by the AppNotificationComboBox
+        AppNotificationComboBox SetSelectedItem(String id);
+    };
+
+    runtimeclass AppNotificationProgressBar
+    {
+        // AppNotificationProgressBar binds to AppNotificationProgressData so the AppNotification will
+        // receive every update to the status and value. In the WinAppSDK, these binding
+        // values are static, so developers won't need to define these binding values
+        // themselves.
+        AppNotificationProgressBar();
+
+        // Setting these properties will remove the data binding with a static value
+        String Title;
+        String Status;
+        Double Value;
+        String ValueStringOverride;
+
+        AppNotificationProgressBar SetTitle(String value);
+        AppNotificationProgressBar BindTitle();
+
+        AppNotificationProgressBar SetStatus(String value);
+        AppNotificationProgressBar BindStatus();
+
+        AppNotificationProgressBar SetValue(Double value);
+        AppNotificationProgressBar BindValue();
+
+        AppNotificationProgressBar SetValueStringOverride(String value);
+        AppNotificationProgressBar BindValueStringOverride();
+    };
+
+    enum AppNotificationSoundEvent
+    {
+        Default,
+        IM,
+        Mail,
+        Reminder,
+        SMS,
+        Alarm,
+        Alarm2,
+        Alarm3,
+        Alarm4,
+        Alarm5,
+        Alarm6,
+        Alarm7,
+        Alarm8,
+        Alarm9,
+        Alarm10,
+        Call,
+        Call2,
+        Call3,
+        Call4,
+        Call5,
+        Call6,
+        Call7,
+        Call8,
+        Call9,
+        Call10,
+    };
+
+    enum AppNotificationScenario
+    {
+        Default, // The normal AppNotification behavior. The AppNotification appears for a short duration, and then automatically dismisses into Notification Center.
+        Reminder, // The notification will stay on screen until the user dismisses it or takes action.
+        Alarm,    // Alarms behave like Reminder, but alarms will additionally loop audio with a default alarm sound.
+        IncomingCall, // Incoming call notifications are displayed pre-expanded in a special call format and stay on the user's screen till dismissed.
+        Urgent, // Important notifications allow users to have more control over what 1st party and 3rd party apps can send them high-priority AppNotifications (urgent/important) that can break through Focus Assist.
+    };
+
+    enum AppNotificationAudioLooping
+    {
+        None, // Audio will not loop
+        Loop, // Audio will loop for the duration of the AppNotification
+    }
+
+    enum AppNotificationDuration
+    {
+        Default, // Default value. AppNotification appears for a short while and then goes into Notification Center.
+        Long, // AppNotification stays on-screen for longer, and then goes into Notification Center.
+    };
+
+    enum AppNotificationImageCrop
+    {
+        Default, // Uses the default renderer to display the image
+        Circle, // Crops the image as a circle.
+    }
+
+    runtimeclass AppNotificationBuilder
+    {
+        AppNotificationBuilder();
+
+        // Adds arguments to the launch attribute to return when AppNotification is clicked.
+        AppNotificationBuilder AddArgument(String key, String value);
+
+        // Sets the timeStamp of the AppNotification to when it was constructed instead of when it was sent.
+        AppNotificationBuilder SetTimeStamp(Windows.Foundation.DateTime value);
+
+        AppNotificationBuilder SetScenario(AppNotificationScenario value);
+        static Boolean IsUrgentScenarioSupported();
+
+        AppNotificationBuilder AddText(String text);
+        AppNotificationBuilder AddText(String text, AppNotificationTextProperties properties);
+
+        AppNotificationBuilder SetAttributionText(String text);
+        AppNotificationBuilder SetAttributionText(String text, String language);
+
+        AppNotificationBuilder SetInlineImage(Windows.Foundation.Uri imageUri);
+        AppNotificationBuilder SetInlineImage(Windows.Foundation.Uri imageUri, AppNotificationImageCrop imageCrop);
+        AppNotificationBuilder SetInlineImage(Windows.Foundation.Uri imageUri, AppNotificationImageCrop imagecrop, String alternateText);
+
+        AppNotificationBuilder SetAppLogoOverride(Windows.Foundation.Uri imageUri);
+        AppNotificationBuilder SetAppLogoOverride(Windows.Foundation.Uri imageUri, String alternateText);
+        AppNotificationBuilder SetAppLogoOverride(Windows.Foundation.Uri imageUri, AppNotificationImageCrop imageCrop, String alternateText);
+
+        AppNotificationBuilder SetHeroImage(Windows.Foundation.Uri imageUri);
+        AppNotificationBuilder SetHeroImage(Windows.Foundation.Uri imageUri, String alternateText);
+
+        AppNotificationBuilder SetAudioUri(Windows.Foundation.Uri audioUri);
+        AppNotificationBuilder SetAudioUri(Windows.Foundation.Uri audioUri, AppNotificationAudioLooping loop);
+
+        AppNotificationBuilder SetAudioEvent(AppNotificationSoundEvent appNotificationSoundEvent);
+        AppNotificationBuilder SetAudioEvent(AppNotificationSoundEvent appNotificationSoundEvent, AppNotificationAudioLooping loop);
+
+        AppNotificationBuilder MuteAudio();
+
+        AppNotificationBuilder AddTextBox(String id);
+        AppNotificationBuilder AddTextBox(String id, String placeHolderText, String title);
+
+        AppNotificationBuilder AddButton(AppNotificationButton value);
+
+        AppNotificationBuilder AddComboBox(AppNotificationComboBox value);
+
+        AppNotificationBuilder AddProgressBar(AppNotificationProgressBar value);
+
+        // Constructs a WindowsAppSDK AppNotification object with the XML payload
+        AppNotification BuildNotification();
+
+        // AppNotification properties
+        AppNotificationBuilder SetTag(String value);
+        AppNotificationBuilder SetGroup(String group);
+    };
+}
+```
diff --git a/specs/AppNotifications/AppNotificationContentSpec/AppNotificationExample.png b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationExample.png
new file mode 100644
index 0000000000..5ca0e87cce
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/AppNotificationTextExample.png b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationTextExample.png
new file mode 100644
index 0000000000..1715a6805a
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationTextExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/AppNotificationWithAvatarImage.png b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationWithAvatarImage.png
new file mode 100644
index 0000000000..df66a47b6d
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/AppNotificationWithAvatarImage.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/ButtonContextMenuExample.png b/specs/AppNotifications/AppNotificationContentSpec/ButtonContextMenuExample.png
new file mode 100644
index 0000000000..b1350ab60f
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/ButtonContextMenuExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/ButtonExample.png b/specs/AppNotifications/AppNotificationContentSpec/ButtonExample.png
new file mode 100644
index 0000000000..bebcb17d47
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/ButtonExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/ButtonSuccessExample.png b/specs/AppNotifications/AppNotificationContentSpec/ButtonSuccessExample.png
new file mode 100644
index 0000000000..b7dd7415eb
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/ButtonSuccessExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/ButtonToolTipExample.png b/specs/AppNotifications/AppNotificationContentSpec/ButtonToolTipExample.png
new file mode 100644
index 0000000000..74ecd5cc26
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/ButtonToolTipExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/ComboBoxExample.png b/specs/AppNotifications/AppNotificationContentSpec/ComboBoxExample.png
new file mode 100644
index 0000000000..026e5d3f77
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/ComboBoxExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/CroppedAppLogoOverrideExample.png b/specs/AppNotifications/AppNotificationContentSpec/CroppedAppLogoOverrideExample.png
new file mode 100644
index 0000000000..075ed881ae
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/CroppedAppLogoOverrideExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/HeroImageExample.png b/specs/AppNotifications/AppNotificationContentSpec/HeroImageExample.png
new file mode 100644
index 0000000000..b94301af61
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/HeroImageExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/IncomingCallExample.png b/specs/AppNotifications/AppNotificationContentSpec/IncomingCallExample.png
new file mode 100644
index 0000000000..931b7e4830
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/IncomingCallExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/IncomingCallSimpleExample.png b/specs/AppNotifications/AppNotificationContentSpec/IncomingCallSimpleExample.png
new file mode 100644
index 0000000000..c8224f327f
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/IncomingCallSimpleExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/InlineImageExample.png b/specs/AppNotifications/AppNotificationContentSpec/InlineImageExample.png
new file mode 100644
index 0000000000..5833b535c0
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/InlineImageExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/ProgressBarExample1.png b/specs/AppNotifications/AppNotificationContentSpec/ProgressBarExample1.png
new file mode 100644
index 0000000000..f7e620b737
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/ProgressBarExample1.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/ProgressBarExample2.png b/specs/AppNotifications/AppNotificationContentSpec/ProgressBarExample2.png
new file mode 100644
index 0000000000..e8fb0139bc
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/ProgressBarExample2.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/TextBoxExample.png b/specs/AppNotifications/AppNotificationContentSpec/TextBoxExample.png
new file mode 100644
index 0000000000..956b0a94fd
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/TextBoxExample.png differ
diff --git a/specs/AppNotifications/AppNotificationContentSpec/TextExample.png b/specs/AppNotifications/AppNotificationContentSpec/TextExample.png
new file mode 100644
index 0000000000..5e514aa9dc
Binary files /dev/null and b/specs/AppNotifications/AppNotificationContentSpec/TextExample.png differ
diff --git a/test/AppNotificationBuilderTests/APITests.cpp b/test/AppNotificationBuilderTests/APITests.cpp
new file mode 100644
index 0000000000..0c12984176
--- /dev/null
+++ b/test/AppNotificationBuilderTests/APITests.cpp
@@ -0,0 +1,667 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+
+namespace winrt
+{
+    using namespace winrt::Microsoft::Windows::AppNotifications::Builder;
+}
+
+namespace Test::AppNotification::Builder
+{
+    inline const winrt::Windows::Foundation::Uri c_sampleUri{ L"http://www.microsoft.com" };
+
+    class APITests
+    {
+    public:
+        BEGIN_TEST_CLASS(APITests)
+            TEST_CLASS_PROPERTY(L"ThreadingModel", L"MTA")
+            TEST_CLASS_PROPERTY(L"RunFixtureAs:Class", L"RestrictedUser")
+        END_TEST_CLASS()
+
+        TEST_CLASS_SETUP(ClassInit)
+        {
+            ::Test::Bootstrap::Setup();
+            return true;
+        }
+
+        TEST_CLASS_CLEANUP(ClassUninit)
+        {
+            ::Test::Bootstrap::Cleanup();
+            return true;
+        }
+
+       TEST_METHOD_SETUP(MethodSetup)
+        {
+
+            ::Test::Bootstrap::SetupBootstrap();
+            ::WindowsAppRuntime::VersionInfo::TestInitialize(::Test::Bootstrap::TP::WindowsAppRuntimeFramework::c_PackageFamilyName,
+                ::Test::Bootstrap::TP::WindowsAppRuntimeMain::c_PackageFamilyName);
+            return true;
+        }
+
+        TEST_METHOD_CLEANUP(MethodCleanup)
+        {
+            ::WindowsAppRuntime::VersionInfo::TestShutdown();
+            ::Test::Bootstrap::CleanupBootstrap();
+            return true;
+        }
+
+        TEST_METHOD(AppNotificationBuilderDefault)
+        {
+            auto builder{ winrt::AppNotificationBuilder() };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual></toast>"};
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetTimeStamp)
+        {
+            std::wstring dateTimeFormat{ L"%d/%m/%Y %H:%M:%S" };
+            std::wistringstream ss(L"22/12/2016 01:12:10");
+
+            struct tm dateTime {};
+            ss >> std::get_time(&dateTime, dateTimeFormat.c_str());
+            std::time_t time{ mktime(&dateTime) };
+            auto timeStamp{ winrt::clock::from_time_t(time) };
+
+            auto builder{ winrt::AppNotificationBuilder().SetTimeStamp(timeStamp) };
+            auto expected{ L"<toast displayTimestamp='2016-12-22T09:12:10Z'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddOneArgument)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddArgument(L"key", L"value") };
+            auto expected{ L"<toast launch='key=value'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTwoArguments)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddArgument(L"key1", L"value1").AddArgument(L"key2", L"value2") };
+            auto expected{ L"<toast launch='key1=value1;key2=value2'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddArgumentEmptyValue)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddArgument(L"key", L"") };
+            auto expected{ L"<toast launch='key'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddArgumentWithPercentChar)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddArgument(L"k%ey", L"v%alue") };
+            auto expected{ L"<toast launch='k%25ey=v%25alue'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddArgumentWithEqualChar)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddArgument(L"k=ey", L"v=alue") };
+            auto expected{ L"<toast launch='k%3Dey=v%3Dalue'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddArgumentWithSemicolonChar)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddArgument(L"k;ey", L"v;alue") };
+            auto expected{ L"<toast launch='k%3Bey=v%3Balue'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(DecodeArguments)
+        {
+            VERIFY_ARE_EQUAL(Decode(L"key%3B"), L"key;");
+            VERIFY_ARE_EQUAL(Decode(L"key%3D"), L"key=");
+            VERIFY_ARE_EQUAL(Decode(L"key%25"), L"key%");
+            VERIFY_ARE_EQUAL(Decode(L"key%3B%3D%25"), L"key;=%");
+            VERIFY_ARE_EQUAL(Decode(L"%25%25%25"), L"%%%");
+
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddArgumentEmptyKey)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder().AddArgument(L"", L""), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetReminderScenario)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetScenario(winrt::AppNotificationScenario::Reminder) };
+            auto expected{ L"<toast scenario='reminder'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetAlarmScenario)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetScenario(winrt::AppNotificationScenario::Alarm) };
+            auto expected{ L"<toast scenario='alarm'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetIncomingCallScenario)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetScenario(winrt::AppNotificationScenario::IncomingCall) };
+            auto expected{ L"<toast scenario='incomingCall'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetUrgentScenario)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetScenario(winrt::AppNotificationScenario::Urgent) };
+            auto expected{ L"<toast scenario='urgent'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddText)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddText(L"content") };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><text>content</text></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextWithLanguage)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                            .AddText(L"content", winrt::AppNotificationTextProperties()
+                                .SetLanguage(L"en-US"))
+            };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><text lang='en-US'>content</text></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextWithMaxLines)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                            .AddText(L"content", winrt::AppNotificationTextProperties()
+                                .SetMaxLines(2))
+            };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><text hint-maxLines='2'>content</text></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextWithCallScenarioAlign)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                            .AddText(L"content", winrt::AppNotificationTextProperties()
+                                .SetIncomingCallAlignment())
+            };
+            auto expected{ L"<toast scenario='incomingCall'><visual><binding template='ToastGeneric'><text hint-callScenarioCenterAlign='true'>content</text></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextWithAllProperties)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                            .AddText(L"content", winrt::AppNotificationTextProperties()
+                                .SetLanguage(L"en-US")
+                                .SetMaxLines(2)
+                                .SetIncomingCallAlignment())
+            };
+            auto expected{ L"<toast scenario='incomingCall'><visual><binding template='ToastGeneric'><text lang='en-US' hint-maxLines='2' hint-callScenarioCenterAlign='true'>content</text></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextThrows)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddText(L"content")
+                .AddText(L"content")
+                .AddText(L"content")
+                .AddText(L"content"), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddAttributionText)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetAttributionText(L"content") };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><text placement='attribution'>content</text></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddAttributionTextWithLanguage)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetAttributionText(L"content", L"en-US")};
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><text placement='attribution' lang='en-US'>content</text></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetInlineImage)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetInlineImage(c_sampleUri) };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><image src='http://www.microsoft.com/'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetInlineImageWithProperties)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetInlineImage(c_sampleUri, winrt::AppNotificationImageCrop::Circle, L"altText")};
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><image src='http://www.microsoft.com/' alt='altText' hint-crop='circle'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetAppLogoOverride)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetAppLogoOverride(c_sampleUri) };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><image placement='appLogoOverride' src='http://www.microsoft.com/'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetAppLogoOverrideProperties)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetAppLogoOverride(c_sampleUri, winrt::AppNotificationImageCrop::Circle, L"altText") };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><image placement='appLogoOverride' src='http://www.microsoft.com/' alt='altText' hint-crop='circle'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetHeroImage)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetHeroImage(c_sampleUri) };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><image placement='hero' src='http://www.microsoft.com/'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetHeroImageWithAlt)
+        {
+            auto builder{ winrt::AppNotificationBuilder().SetHeroImage(c_sampleUri, L"altText") };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><image placement='hero' src='http://www.microsoft.com/' alt='altText'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddButton)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content")
+                .AddArgument(L"key", L"value"))
+            };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><actions><action content='content' arguments='key=value'/></actions></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddButtonWithPlacement)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content")
+                .AddArgument(L"key", L"value")
+                .SetContextMenuPlacement())
+            };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><actions><action content='content' arguments='key=value' placement='contextMenu'/></actions></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderTooManyButtons)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content").AddArgument(L"key1", L"value1"))
+                .AddButton(winrt::AppNotificationButton(L"content").AddArgument(L"key2", L"value2"))
+                .AddButton(winrt::AppNotificationButton(L"content").AddArgument(L"key3", L"value3"))
+                .AddButton(winrt::AppNotificationButton(L"content").AddArgument(L"key4", L"value4"))
+                .AddButton(winrt::AppNotificationButton(L"content").AddArgument(L"key5", L"value5"))
+                .AddButton(winrt::AppNotificationButton(L"content").AddArgument(L"key6", L"value6")), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddButtonWithProtocolActivation)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content")
+                .SetInvokeUri(c_sampleUri))
+            };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><actions><action content='content' arguments='http://www.microsoft.com/' activationType='protocol'/></actions></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddButtonWithProperties)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content")
+                .AddArgument(L"key", L"value")
+                .SetButtonStyle(winrt::AppNotificationButtonStyle::Success)
+                .SetIcon(c_sampleUri)
+                .SetInputId(L"inputId")
+                .SetToolTip(L"toolTip"))
+            };
+            auto expected{ L"<toast useButtonStyle='true'><visual><binding template='ToastGeneric'></binding></visual><actions><action content='content' arguments='key=value' imageUri='http://www.microsoft.com/' hint-inputId='inputId' hint-buttonStyle='Success' hint-toolTip='toolTip'/></actions></toast>"};
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddButtonWithEmptyKey)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content")
+                    .AddArgument(L"", L"value")), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddButtonWithArgumentAndProtocol)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content")
+                    .AddArgument(L"key", L"value")
+                    .SetInvokeUri(c_sampleUri)), E_INVALIDARG);
+
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddButton(winrt::AppNotificationButton(L"content")
+                    .SetInvokeUri(c_sampleUri)
+                    .AddArgument(L"key", L"value")), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetAudioWithUri)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                    .SetAudioUri(c_sampleUri) };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><audio src='http://www.microsoft.com/'/></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetAudioWithUriAndDuration)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                    .SetDuration(winrt::AppNotificationDuration::Long)
+                    .SetAudioUri(c_sampleUri, winrt::AppNotificationAudioLooping::Loop) };
+            auto expected{ L"<toast duration='long'><visual><binding template='ToastGeneric'></binding></visual><audio src='http://www.microsoft.com/' loop='true'/></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetAudioWithSoundEvent)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                    .SetAudioEvent(winrt::AppNotificationSoundEvent::Reminder) };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><audio src='ms-winsoundevent:Notification.Reminder'/></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderSetAudioWithSoundEventAndDuration)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                    .SetDuration(winrt::AppNotificationDuration::Long)
+                    .SetAudioEvent(winrt::AppNotificationSoundEvent::Reminder, winrt::AppNotificationAudioLooping::Loop) };
+            auto expected{ L"<toast duration='long'><visual><binding template='ToastGeneric'></binding></visual><audio src='ms-winsoundevent:Notification.Reminder' loop='true'/></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderMuteAudio)
+        {
+            auto builder{ winrt::AppNotificationBuilder().MuteAudio() };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><audio silent='true'/></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderBuildNotificationWithTooLargePayload)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddText(std::wstring(5120, 'A').c_str())
+                .BuildNotification(), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationAddProgressBar)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddText(L"Downloading this week's new music...")
+                .AddProgressBar(winrt::AppNotificationProgressBar()
+                    .BindTitle()
+                    .BindValueStringOverride()) };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><text>Downloading this week&apos;s new music...</text><progress title='{progressTitle}' status='{progressStatus}' value='{progressValue}' valueStringOverride='{progressValueString}'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationAddMoreThanOneProgressBar)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddText(L"Downloading this week's new music...")
+                .AddProgressBar(winrt::AppNotificationProgressBar()
+                    .BindTitle()
+                    .BindValueStringOverride())
+                .AddProgressBar(winrt::AppNotificationProgressBar()
+                    .SetValue(0.8)
+                    .SetStatus(L"Still downloading...")) };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'><text>Downloading this week&apos;s new music...</text><progress title='{progressTitle}' status='{progressStatus}' value='{progressValue}' valueStringOverride='{progressValueString}'/><progress status='Still downloading...' value='0.8'/></binding></visual></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationProgressBarDefaults)
+        {
+            auto progressBar{ winrt::AppNotificationProgressBar() };
+            auto expected{ L"<progress status='{progressStatus}' value='{progressValue}'/>" };
+
+            VERIFY_ARE_EQUAL(progressBar.as<winrt::Windows::Foundation::IStringable>().ToString(), expected);
+        }
+
+        TEST_METHOD(AppNotificationProgressBarSetSpecificValue)
+        {
+            auto progressBar{ winrt::AppNotificationProgressBar() };
+            progressBar.Value(0.8);
+            auto expected{ L"<progress status='{progressStatus}' value='0.8'/>" };
+
+            VERIFY_ARE_EQUAL(progressBar.as<winrt::Windows::Foundation::IStringable>().ToString(), expected);
+        }
+
+        TEST_METHOD(AppNotificationProgressBarSetValueLargerThanOne)
+        {
+            auto progressBar{ winrt::AppNotificationProgressBar() };
+            VERIFY_THROWS_HR(progressBar.Value(1.01), E_INVALIDARG);
+
+            VERIFY_THROWS_HR(winrt::AppNotificationProgressBar().SetValue(1.01), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationProgressBarSetValueSmallerThanZero)
+        {
+            auto progressBar{ winrt::AppNotificationProgressBar() };
+            VERIFY_THROWS_HR(progressBar.Value(-0.1), E_INVALIDARG);
+
+            VERIFY_THROWS_HR(winrt::AppNotificationProgressBar().SetValue(-0.1), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationProgressBarSetSpecificValueThenChangeToBind)
+        {
+            auto progressBar{ winrt::AppNotificationProgressBar() };
+            progressBar.Value(0.8);
+            progressBar.BindValue();
+            auto expected{ L"<progress status='{progressStatus}' value='{progressValue}'/>" };
+
+            VERIFY_ARE_EQUAL(progressBar.as<winrt::Windows::Foundation::IStringable>().ToString(), expected);
+        }
+
+        TEST_METHOD(AppNotificationProgressBarBindTitleThenChangeToSpecificText)
+        {
+            auto progressBar{ winrt::AppNotificationProgressBar()
+                .BindTitle()
+                .SetTitle(L"Specific title") };
+            auto expected{ L"<progress title='Specific title' status='{progressStatus}' value='{progressValue}'/>" };
+
+            VERIFY_ARE_EQUAL(progressBar.as<winrt::Windows::Foundation::IStringable>().ToString(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextBox)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddTextBox(L"input1") };
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><actions><input id='input1' type='text'/></actions></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextBoxWithEmptyId)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddTextBox(L""), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextBoxWithEmptyIdAndPlaceHolderTextAndTitle)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddTextBox(L"", L"placeholder text", L"title"), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTooManyTextBoxes)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddTextBox(L"input1")
+                .AddTextBox(L"input2")
+                .AddTextBox(L"input3")
+                .AddTextBox(L"input4")
+                .AddTextBox(L"input5")
+                .AddTextBox(L"input6"), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTextBoxWithPlaceHolderTextAndTitle)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddTextBox(L"some input id", L"Some placeholder text", L"A Title")};
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><actions><input id='some input id' type='text' placeHolderContent='Some placeholder text' title='A Title'/></actions></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddComboBox)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox1")
+                    .AddItem(L"item1", L"item1 text")
+                    .AddItem(L"item2", L"item2 text")
+                    .AddItem(L"item3", L"item3 text")
+                    .SetTitle(L"ComboBox Title")
+                    .SetSelectedItem(L"item2"))};
+            auto expected{ L"<toast><visual><binding template='ToastGeneric'></binding></visual><actions><input id='comboBox1' type='selection' title='ComboBox Title' defaultInput='item2'><selection id='item1' content='item1 text'/><selection id='item2' content='item2 text'/><selection id='item3' content='item3 text'/></input></actions></toast>" };
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTooManyComboBox)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddTextBox(L"input1")
+                .AddTextBox(L"input2")
+                .AddTextBox(L"input3")
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox1")
+                    .AddItem(L"item1", L"item1 text"))
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox2")
+                    .AddItem(L"item1", L"item1 text"))
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox3")
+                    .AddItem(L"item1", L"item1 text")), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderAddTooManyInputElements)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationBuilder()
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox1")
+                    .AddItem(L"item1", L"item1 text"))
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox2")
+                    .AddItem(L"item1", L"item1 text"))
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox3")
+                    .AddItem(L"item1", L"item1 text"))
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox4")
+                    .AddItem(L"item1", L"item1 text"))
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox5")
+                    .AddItem(L"item1", L"item1 text"))
+                .AddComboBox(winrt::AppNotificationComboBox(L"comboBox6")
+                    .AddItem(L"item1", L"item1 text")), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationComboBoxAddTooManySelectionItems)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationComboBox(L"comboBox1")
+                    .AddItem(L"item1", L"item1 text")
+                    .AddItem(L"item2", L"item2 text")
+                    .AddItem(L"item3", L"item3 text")
+                    .AddItem(L"item4", L"item4 text")
+                    .AddItem(L"item5", L"item5 text")
+                    .AddItem(L"item6", L"item6 text"), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationComboBoxAddFiveSelectionItems)
+        {
+            auto comboBox{ winrt::AppNotificationComboBox(L"comboBox1")
+                    .AddItem(L"item1", L"item1 text")
+                    .AddItem(L"item2", L"item2 text")
+                    .AddItem(L"item3", L"item3 text")
+                    .AddItem(L"item4", L"item4 text")
+                    .AddItem(L"item5", L"item5 text") };
+            auto expected{ L"<input id='comboBox1' type='selection'><selection id='item1' content='item1 text'/><selection id='item2' content='item2 text'/><selection id='item3' content='item3 text'/><selection id='item4' content='item4 text'/><selection id='item5' content='item5 text'/></input>" };
+
+            VERIFY_ARE_EQUAL(comboBox.as<winrt::Windows::Foundation::IStringable>().ToString(), expected);
+        }
+
+        TEST_METHOD(AppNotificationComboBoxAddSelectionItemWithoutAnId)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationComboBox(L"comboBox1")
+                .AddItem(L"", L"item text"), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationComboBoxAddTwoSelectionItemsWithSameId)
+        {
+            auto comboBox{ winrt::AppNotificationComboBox(L"comboBox1")
+                    .AddItem(L"item1", L"item1 text")
+                    .AddItem(L"item1", L"item2 text") };
+            auto expected{ L"<input id='comboBox1' type='selection'><selection id='item1' content='item2 text'/></input>" };
+
+            VERIFY_ARE_EQUAL(comboBox.as<winrt::Windows::Foundation::IStringable>().ToString(), expected);
+        }
+
+        TEST_METHOD(AppNotificationComboBoxSetSelectedItemWithoutAnId)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationComboBox(L"comboBox1")
+                .SetSelectedItem(L""), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationCreateComboBoxWithoutAnId)
+        {
+            VERIFY_THROWS_HR(winrt::AppNotificationComboBox(L""), E_INVALIDARG);
+        }
+
+        TEST_METHOD(AppNotificationBuilderEscapeXmlCharacters)
+        {
+            auto builder{ winrt::AppNotificationBuilder().AddText(LR"(&"'<>)") };
+            std::wstring expected{ L"<toast><visual><binding template='ToastGeneric'><text>&amp;&quot;&apos;&lt;&gt;</text></binding></visual></toast>"};
+
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+        }
+
+        TEST_METHOD(AppNotificationBuilderArgumentsWithXmlCharacters)
+        {
+            auto builder{ winrt::AppNotificationBuilder()
+                            .AddArgument(LR"(&;"='%<>)", L"")
+                            .AddArgument(LR"(&"'<>)", L";=%")};
+
+            std::wstring expected{ L"<toast launch='&amp;%3B&quot;%3D&apos;%25&lt;&gt;;&amp;&quot;&apos;&lt;&gt;=%3B%3D%25'><visual><binding template='ToastGeneric'></binding></visual></toast>" };
+            VERIFY_ARE_EQUAL(builder.BuildNotification().Payload(), expected);
+
+            VERIFY_ARE_EQUAL(Decode(LR"(&%3B"%3D'%25<>)"), LR"(&;"='%<>)");
+            VERIFY_ARE_EQUAL(Decode(L"%3B%3D%25"), L";=%");
+        }
+    };
+}
diff --git a/test/AppNotificationBuilderTests/AppNotificationBuilderTests.cpp b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.cpp
new file mode 100644
index 0000000000..d529e99d2e
--- /dev/null
+++ b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.cpp
@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+#include "AppNotificationBuilderTests.h"
diff --git a/test/AppNotificationBuilderTests/AppNotificationBuilderTests.h b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.h
new file mode 100644
index 0000000000..6e2b332199
--- /dev/null
+++ b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.h
@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#pragma once
\ No newline at end of file
diff --git a/test/AppNotificationBuilderTests/AppNotificationBuilderTests.vcxproj b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.vcxproj
new file mode 100644
index 0000000000..2d92e195b0
--- /dev/null
+++ b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.vcxproj
@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.props')" />
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{131de0c4-aa1e-4649-b5bc-7b43508fa93a}</ProjectGuid>
+    <RootNamespace>AppNotificationBuilderTests</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <UseDebugLibraries>false</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared" />
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <UseFullPaths>true</UseFullPaths>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>$(RepoRoot)\test\inc;$(RepoRoot)\Dev\Common;$(RepoRoot)\Dev\AppNotifications\AppNotificationBuilder;$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories);$(OutDir)\..\WindowsAppRuntime_DLL;$(OutDir)\..\WindowsAppRuntime_BootstrapDLL</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="$(WindowsAppSDKBuildPipeline) == '1'">$(RepoRoot);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>onecore.lib;onecoreuap.lib;Microsoft.WindowsAppRuntime.lib;wex.common.lib;wex.logger.lib;te.common.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories);$(OutDir)\..\WindowsAppRuntime_DLL</AdditionalLibraryDirectories>
+      <DelayLoadDLLs>Microsoft.WindowsAppRuntime.Bootstrap.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
+      <DelayLoadDLLs>Microsoft.WindowsAppRuntime.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="APITests.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.Windows.AppNotifications.Builder">
+      <HintPath>$(OutDir)\..\WindowsAppRuntime_DLL\Microsoft.Windows.AppNotifications.Builder.winmd</HintPath>
+      <IsWinMDFile>true</IsWinMDFile>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.Windows.AppNotifications">
+      <HintPath>$(OutDir)\..\WindowsAppRuntime_DLL\Microsoft.Windows.AppNotifications.winmd</HintPath>
+      <IsWinMDFile>true</IsWinMDFile>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\dev\WindowsAppRuntime_BootstrapDLL\WindowsAppRuntime_BootstrapDLL.vcxproj">
+      <Project>{f76b776e-86f5-48c5-8fc7-d2795ecc9746}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\packages\Microsoft.Taef.10.58.210222006-develop\build\Microsoft.Taef.targets" Condition="Exists('..\..\packages\Microsoft.Taef.10.58.210222006-develop\build\Microsoft.Taef.targets')" />
+    <Import Project="..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.220201.1\build\native\Microsoft.Windows.ImplementationLibrary.targets" Condition="Exists('..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.220201.1\build\native\Microsoft.Windows.ImplementationLibrary.targets')" />
+    <Import Project="..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.targets')" />
+  </ImportGroup>
+  <Target Name="CopyFiles" AfterTargets="AfterBuild">
+    <Copy SourceFiles="$(OutDir)\..\WindowsAppRuntime_BootstrapDLL\Microsoft.WindowsAppRuntime.Bootstrap.dll" DestinationFolder="$(OutDir)" />
+    <Copy SourceFiles="$(OutDir)\..\WindowsAppRuntime_DLL\Microsoft.Internal.FrameworkUdk.dll" DestinationFolder="$(OutDir)" />
+  </Target>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\packages\Microsoft.Taef.10.58.210222006-develop\build\Microsoft.Taef.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\Microsoft.Taef.10.58.210222006-develop\build\Microsoft.Taef.targets'))" />
+    <Error Condition="!Exists('..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.220201.1\build\native\Microsoft.Windows.ImplementationLibrary.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.220201.1\build\native\Microsoft.Windows.ImplementationLibrary.targets'))" />
+    <Error Condition="!Exists('..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.props'))" />
+    <Error Condition="!Exists('..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\Microsoft.Windows.CppWinRT.2.0.220531.1\build\native\Microsoft.Windows.CppWinRT.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/test/AppNotificationBuilderTests/AppNotificationBuilderTests.vcxproj.filters b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.vcxproj.filters
new file mode 100644
index 0000000000..bb2b67149b
--- /dev/null
+++ b/test/AppNotificationBuilderTests/AppNotificationBuilderTests.vcxproj.filters
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tga;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4b514c96-7ee8-44e5-aeb3-64c1bc0d6b91}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{9f96baa5-3d60-4ef4-9ff2-5a5fe8d7367b}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="APITests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/test/AppNotificationBuilderTests/packages.config b/test/AppNotificationBuilderTests/packages.config
new file mode 100644
index 0000000000..beec33edf7
--- /dev/null
+++ b/test/AppNotificationBuilderTests/packages.config
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.Taef" version="10.58.210222006-develop" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.220531.1" targetFramework="native" />
+  <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.220201.1" targetFramework="native" />
+</packages>
diff --git a/test/AppNotificationBuilderTests/pch.cpp b/test/AppNotificationBuilderTests/pch.cpp
new file mode 100644
index 0000000000..6ff32612c1
--- /dev/null
+++ b/test/AppNotificationBuilderTests/pch.cpp
@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#include "pch.h"
+
+// When you are using pre-compiled headers, this source file is necessary for compilation to succeed.
diff --git a/test/AppNotificationBuilderTests/pch.h b/test/AppNotificationBuilderTests/pch.h
new file mode 100644
index 0000000000..b673f9e3a1
--- /dev/null
+++ b/test/AppNotificationBuilderTests/pch.h
@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+#ifndef PCH_H
+#define PCH_H
+
+#include <unknwn.h>
+
+#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
+#include <windows.h>
+#include <sddl.h>
+#include <appmodel.h>
+
+#include <wil/result.h>
+#include <wil/cppwinrt.h>
+#include <wil/token_helpers.h>
+#include <wil/resource.h>
+#include <wrl.h>
+#include <WexTestClass.h>
+
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+#include <wil/result_macros.h>
+#include <wil/com.h>
+
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
+
+#include <winrt/Windows.Networking.PushNotifications.h>
+#include <winrt/Windows.ApplicationModel.Activation.h>
+#include <winrt/Windows.Management.Deployment.h>
+#include <winrt/Windows.Security.Cryptography.h>
+#include <winrt/Windows.Storage.h>
+#include <winrt/Windows.System.h>
+#include <WindowsAppRuntime.Test.Package.h>
+#include <WindowsAppRuntime.Test.TAEF.h>
+#include <WindowsAppRuntime.Test.Bootstrap.h>
+#include <windows.applicationmodel.h>
+#include <windows.applicationmodel.background.h>
+#include <ShObjIdl_core.h>
+
+#include <winrt/Microsoft.Windows.AppNotifications.h>
+#include <winrt/Microsoft.Windows.AppNotifications.Builder.h>
+#include <AppNotificationBuilderUtility.h>
+#include <WindowsAppRuntime.SelfContained.h>
+#include <WindowsAppRuntime.VersionInfo.h>
+
+#define VERIFY_THROWS_HR(expression, hr)        \
+            VERIFY_THROWS_SPECIFIC(expression,          \
+                winrt::hresult_error,                   \
+                [&](winrt::hresult_error e) -> bool     \
+                {                                       \
+                    return (e.code() == hr);    \
+                })
+
+namespace TP = ::Test::Packages;
+namespace TAEF = ::Test::TAEF;
+#endif //PCH_H
diff --git a/test/DynamicDependency/data/Microsoft.WindowsAppRuntime.Framework/appxmanifest.xml b/test/DynamicDependency/data/Microsoft.WindowsAppRuntime.Framework/appxmanifest.xml
index ba23f37f21..70a43a9ca6 100644
--- a/test/DynamicDependency/data/Microsoft.WindowsAppRuntime.Framework/appxmanifest.xml
+++ b/test/DynamicDependency/data/Microsoft.WindowsAppRuntime.Framework/appxmanifest.xml
@@ -81,6 +81,16 @@
             <ActivatableClass ActivatableClassId="Microsoft.Windows.AppNotifications.AppNotificationActivatedEventArgs" ThreadingModel="both" />
         </InProcessServer>
     </Extension>
+    <Extension Category="windows.activatableClass.inProcessServer">
+        <InProcessServer>
+            <Path>Microsoft.WindowsAppRuntime.dll</Path>
+            <ActivatableClass ActivatableClassId="Microsoft.Windows.AppNotifications.Builder.AppNotificationBuilder" ThreadingModel="both" />
+            <ActivatableClass ActivatableClassId="Microsoft.Windows.AppNotifications.Builder.AppNotificationTextProperties" ThreadingModel="both" />
+            <ActivatableClass ActivatableClassId="Microsoft.Windows.AppNotifications.Builder.AppNotificationButton" ThreadingModel="both" />
+            <ActivatableClass ActivatableClassId="Microsoft.Windows.AppNotifications.Builder.AppNotificationProgressBar" ThreadingModel="both" />
+            <ActivatableClass ActivatableClassId="Microsoft.Windows.AppNotifications.Builder.AppNotificationComboBox" ThreadingModel="both" />
+        </InProcessServer>
+    </Extension>
     <Extension Category="windows.activatableClass.inProcessServer">
         <InProcessServer>
             <Path>Microsoft.WindowsAppRuntime.dll</Path>
diff --git a/test/TestApps/ToastNotificationsDemoApp/ToastNotificationsDemoApp.vcxproj b/test/TestApps/ToastNotificationsDemoApp/ToastNotificationsDemoApp.vcxproj
index c12b365ef4..2ec99b98fc 100644
--- a/test/TestApps/ToastNotificationsDemoApp/ToastNotificationsDemoApp.vcxproj
+++ b/test/TestApps/ToastNotificationsDemoApp/ToastNotificationsDemoApp.vcxproj
@@ -211,6 +211,11 @@
       <IsWinMDFile>true</IsWinMDFile>
       <Implementation>$(OutDir)\..\WindowsAppRuntime_DLL\Microsoft.WindowsAppRuntime.dll</Implementation>
     </Reference>
+    <Reference Include="Microsoft.Windows.AppNotifications.Builder">
+      <HintPath>$(OutDir)\..\WindowsAppRuntime_DLL\Microsoft.Windows.AppNotifications.Builder.winmd</HintPath>
+      <IsWinMDFile>true</IsWinMDFile>
+      <Implementation>$(OutDir)\..\WindowsAppRuntime_DLL\Microsoft.WindowsAppRuntime.dll</Implementation>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\dev\WindowsAppRuntime_BootstrapDLL\WindowsAppRuntime_BootstrapDLL.vcxproj">
diff --git a/test/TestApps/ToastNotificationsDemoApp/main.cpp b/test/TestApps/ToastNotificationsDemoApp/main.cpp
index 71fb31c6e5..5b8f8db5fd 100644
--- a/test/TestApps/ToastNotificationsDemoApp/main.cpp
+++ b/test/TestApps/ToastNotificationsDemoApp/main.cpp
@@ -18,6 +18,7 @@ namespace winrt
     using namespace winrt::Microsoft::Windows::AppLifecycle;
     using namespace winrt::Microsoft::Windows::PushNotifications;
     using namespace winrt::Microsoft::Windows::AppNotifications;
+    using namespace winrt::Microsoft::Windows::AppNotifications::Builder;
     using namespace winrt::Windows::ApplicationModel::Activation;
     using namespace winrt::Windows::ApplicationModel::Background; // BackgroundTask APIs
     using namespace winrt::Windows::Foundation;
@@ -124,7 +125,9 @@ bool PostToastHelper(std::wstring const& tag, std::wstring const& group)
     toast.Tag(tag.c_str());
     toast.Group(group.c_str());
 
-    winrt::AppNotificationManager::Default().Show(toast);
+    auto builder{ winrt::AppNotificationBuilder().AddArgument(L"key", L"value").AddArgument(L"key", L"value").SetTag(tag.c_str()).SetGroup(group.c_str())};
+
+    winrt::AppNotificationManager::Default().Show(builder.BuildNotification());
 
     if (toast.Id() == 0)
     {
@@ -170,11 +173,11 @@ int main()
     winrt::event_token token = appNotificationManager.NotificationInvoked([](const auto&, winrt::AppNotificationActivatedEventArgs const& toastArgs)
         {
             std::wcout << L"AppNotification received foreground!\n";
-            winrt::hstring arguments{ toastArgs.Argument() };
-            std::wcout << arguments.c_str() << L"\n\n";
+            winrt::hstring argument{ toastArgs.Argument() };
+            std::wcout << argument.c_str() << L"\n\n";
 
-            winrt::IMap<winrt::hstring, winrt::hstring> userInput{ toastArgs.UserInput() };
-            for (auto pair : userInput)
+            winrt::IMap<winrt::hstring, winrt::hstring> arguments{ toastArgs.Arguments() };
+            for (auto pair : arguments)
             {
                 std::wcout << "Key= " << pair.Key().c_str() << " " << "Value= " << pair.Value().c_str() << L"\n";
             }
@@ -200,11 +203,11 @@ int main()
     {
         std::wcout << L"Activated by AppNotification from background.\n";
         winrt::AppNotificationActivatedEventArgs appNotificationArgs{ args.Data().as<winrt::AppNotificationActivatedEventArgs>() };
-        winrt::hstring arguments{ appNotificationArgs.Argument() };
-        std::wcout << arguments.c_str() << std::endl << std::endl;
+        winrt::hstring argument{ appNotificationArgs.Argument() };
+        std::wcout << argument.c_str() << std::endl << std::endl;
 
-        winrt::IMap<winrt::hstring, winrt::hstring> userInput = appNotificationArgs.UserInput();
-        for (auto pair : userInput)
+        winrt::IMap<winrt::hstring, winrt::hstring> arguments = appNotificationArgs.Arguments();
+        for (auto pair : arguments)
         {
             std::wcout << "Key= " << pair.Key().c_str() << " " << "Value= " << pair.Value().c_str() << L"\n";
         }
diff --git a/test/TestApps/ToastNotificationsDemoApp/pch.h b/test/TestApps/ToastNotificationsDemoApp/pch.h
index 508509bcca..cca5bcb982 100644
--- a/test/TestApps/ToastNotificationsDemoApp/pch.h
+++ b/test/TestApps/ToastNotificationsDemoApp/pch.h
@@ -17,3 +17,4 @@
 #include <winrt/Microsoft.Windows.AppLifecycle.h>
 #include <winrt/Microsoft.Windows.PushNotifications.h>
 #include <winrt/Microsoft.Windows.AppNotifications.h>
+#include <winrt/Microsoft.Windows.AppNotifications.Builder.h>