Add MIT licensed winrt headers

plugins/windows-notification/yolort/LICENSE.md

@@ -0,0 +1,22 @@
+
+Copyright © Microsoft Corporation
+Copyright © 2021, [mjk](https://github.com/Yuubi-san)
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

plugins/windows-notification/yolort/include/WindowsNumerics.impl.h

@@ -0,0 +1,62 @@
+
+// Copyright © 2021, mjk <yuubi-san@users.noreply.github.com>
+
+//  This file is merely to cheaply plug compilability holes in windows 10 winrt
+// APIs that use types from the non-free(?) WindowsNumerics library
+// unconditionally, i. e., unguarded by __has_include.
+//  MinGW will probably have a complete implementation in the future, at which
+// point this file may turn into a part of the problem it solves now (FIXME).
+
+#ifndef YOLORT_WINDOWSNUMERICS_IMPL_H
+#define YOLORT_WINDOWSNUMERICS_IMPL_H
+
+#include <tuple>
+#include <array>
+
+_WINDOWS_NUMERICS_BEGIN_NAMESPACE_
+{
+  // These definitions make sense to *me*, but one cannot be sure microsoft
+  // didn't add proprietary extensions to mathematics.
+
+#define define_mathy_type(name, T, N, ...) \
+  struct name \
+  { \
+  private: \
+    constexpr auto _tie() const \
+    { \
+      auto members = std::tie( __VA_ARGS__ ); \
+      static_assert( std::tuple_size_v<decltype(members)> == (N) ); \
+      return members; \
+    } \
+  public: \
+    T __VA_ARGS__; \
+    friend constexpr auto operator==( const name &l, const name &r ) \
+    { return l._tie() == r._tie(); } \
+  }
+
+#define define_vector_type(T,N,...) define_mathy_type(T##N, T, N, __VA_ARGS__)
+  define_vector_type(float,2,x,y);
+  define_vector_type(float,3,x,y,z);
+  define_vector_type(float,4,x,y,z,w);
+#undef define_vector_type
+
+#define define_matrix_type(T,N,M)   struct T##N##x##M : std::array<T, N*M> {}
+  define_matrix_type(float,2,2);
+  define_matrix_type(float,2,3);
+  define_matrix_type(float,2,4);
+  define_matrix_type(float,3,2);
+  define_matrix_type(float,3,3);
+  define_matrix_type(float,3,4);
+  define_matrix_type(float,4,2);
+  define_matrix_type(float,4,3);
+  define_matrix_type(float,4,4);
+#undef define_matrix_type
+
+  define_mathy_type(quaternion, float, 4, a,b,c,d );
+  define_mathy_type(plane, float, 3+1, x,y,z, d );
+
+#undef define_mathy_type
+}
+_WINDOWS_NUMERICS_END_NAMESPACE_
+
+#endif  // YOLORT_WINDOWSNUMERICS_IMPL_H

plugins/windows-notification/yolort/include/winrt/Windows.Data.Xml.Dom.h

@@ -0,0 +1,3 @@
+#define HEADER_IMPL <winrt/yolort_impl/winrt/Windows.Data.Xml.Dom.h>
+#include <winrt/yolort_impl/yolo.ipp>
+#undef HEADER_IMPL

plugins/windows-notification/yolort/include/winrt/Windows.Foundation.Collections.h

@@ -0,0 +1,3 @@
+#define HEADER_IMPL <winrt/yolort_impl/winrt/Windows.Foundation.Collections.h>
+#include <winrt/yolort_impl/yolo.ipp>
+#undef HEADER_IMPL

plugins/windows-notification/yolort/include/winrt/Windows.Foundation.h

@@ -0,0 +1,3 @@
+#define HEADER_IMPL <winrt/yolort_impl/winrt/Windows.Foundation.h>
+#include <winrt/yolort_impl/yolo.ipp>
+#undef HEADER_IMPL

plugins/windows-notification/yolort/include/winrt/Windows.UI.Notifications.h

@@ -0,0 +1,3 @@
+#define HEADER_IMPL <winrt/yolort_impl/winrt/Windows.UI.Notifications.h>
+#include <winrt/yolort_impl/yolo.ipp>
+#undef HEADER_IMPL

plugins/windows-notification/yolort/include/winrt/Windows.UI.h

@@ -0,0 +1,3 @@
+#define HEADER_IMPL <winrt/yolort_impl/winrt/Windows.UI.h>
+#include <winrt/yolort_impl/yolo.ipp>
+#undef HEADER_IMPL

plugins/windows-notification/yolort/include/winrt/base.h

@@ -0,0 +1,3 @@
+#define HEADER_IMPL <winrt/yolort_impl/winrt/base.h>
+#include <winrt/yolort_impl/yolo.ipp>
+#undef HEADER_IMPL

plugins/windows-notification/yolort/include/winrt/yolort_impl/corostub.hpp

@@ -0,0 +1,28 @@
+
+// Copyright © 2021, mjk <yuubi-san@users.noreply.github.com>
+
+#ifndef YOLORT_IMPL_COROSTUB_HPP
+#define YOLORT_IMPL_COROSTUB_HPP
+
+namespace corostub
+{
+	template<typename=void>
+	struct coroutine_handle
+	{
+		coroutine_handle() = default;
+		coroutine_handle( decltype(nullptr) );
+		void *address() const;
+		void operator()() const {}
+		operator bool() const;
+		static coroutine_handle<> from_address( ... );
+	};
+
+	struct suspend_always {};
+	struct suspend_never  {};
+
+	template<typename, typename...>
+	struct coroutine_traits;
+}
+
+#endif  // YOLORT_IMPL_COROSTUB_HPP
+

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.ApplicationModel.1.h

@@ -0,0 +1,369 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_ApplicationModel_1_H
+#define WINRT_Windows_ApplicationModel_1_H
+#include "Windows.ApplicationModel.0.h"
+namespace winrt::Windows::ApplicationModel
+{
+    struct __declspec(empty_bases) IAppDisplayInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDisplayInfo>
+    {
+        IAppDisplayInfo(std::nullptr_t = nullptr) noexcept {}
+        IAppDisplayInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppInfo>
+    {
+        IAppInfo(std::nullptr_t = nullptr) noexcept {}
+        IAppInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppInfo2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppInfo2>
+    {
+        IAppInfo2(std::nullptr_t = nullptr) noexcept {}
+        IAppInfo2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppInfoStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppInfoStatics>
+    {
+        IAppInfoStatics(std::nullptr_t = nullptr) noexcept {}
+        IAppInfoStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppInstallerInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppInstallerInfo>
+    {
+        IAppInstallerInfo(std::nullptr_t = nullptr) noexcept {}
+        IAppInstallerInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppInstance :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppInstance>
+    {
+        IAppInstance(std::nullptr_t = nullptr) noexcept {}
+        IAppInstance(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppInstanceStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppInstanceStatics>
+    {
+        IAppInstanceStatics(std::nullptr_t = nullptr) noexcept {}
+        IAppInstanceStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDesignModeStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDesignModeStatics>
+    {
+        IDesignModeStatics(std::nullptr_t = nullptr) noexcept {}
+        IDesignModeStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDesignModeStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDesignModeStatics2>
+    {
+        IDesignModeStatics2(std::nullptr_t = nullptr) noexcept {}
+        IDesignModeStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IEnteredBackgroundEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IEnteredBackgroundEventArgs>
+    {
+        IEnteredBackgroundEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IEnteredBackgroundEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IFullTrustProcessLauncherStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IFullTrustProcessLauncherStatics>
+    {
+        IFullTrustProcessLauncherStatics(std::nullptr_t = nullptr) noexcept {}
+        IFullTrustProcessLauncherStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILeavingBackgroundEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILeavingBackgroundEventArgs>
+    {
+        ILeavingBackgroundEventArgs(std::nullptr_t = nullptr) noexcept {}
+        ILeavingBackgroundEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILimitedAccessFeatureRequestResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILimitedAccessFeatureRequestResult>
+    {
+        ILimitedAccessFeatureRequestResult(std::nullptr_t = nullptr) noexcept {}
+        ILimitedAccessFeatureRequestResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILimitedAccessFeaturesStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILimitedAccessFeaturesStatics>
+    {
+        ILimitedAccessFeaturesStatics(std::nullptr_t = nullptr) noexcept {}
+        ILimitedAccessFeaturesStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage>
+    {
+        IPackage(std::nullptr_t = nullptr) noexcept {}
+        IPackage(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage2>
+    {
+        IPackage2(std::nullptr_t = nullptr) noexcept {}
+        IPackage2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage3>
+    {
+        IPackage3(std::nullptr_t = nullptr) noexcept {}
+        IPackage3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage4>
+    {
+        IPackage4(std::nullptr_t = nullptr) noexcept {}
+        IPackage4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage5 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage5>
+    {
+        IPackage5(std::nullptr_t = nullptr) noexcept {}
+        IPackage5(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage6 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage6>
+    {
+        IPackage6(std::nullptr_t = nullptr) noexcept {}
+        IPackage6(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage7 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage7>
+    {
+        IPackage7(std::nullptr_t = nullptr) noexcept {}
+        IPackage7(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackage8 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackage8>
+    {
+        IPackage8(std::nullptr_t = nullptr) noexcept {}
+        IPackage8(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalog :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalog>
+    {
+        IPackageCatalog(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalog(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalog2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalog2>
+    {
+        IPackageCatalog2(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalog2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalog3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalog3>
+    {
+        IPackageCatalog3(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalog3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalog4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalog4>
+    {
+        IPackageCatalog4(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalog4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalogAddOptionalPackageResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalogAddOptionalPackageResult>
+    {
+        IPackageCatalogAddOptionalPackageResult(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalogAddOptionalPackageResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalogAddResourcePackageResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalogAddResourcePackageResult>
+    {
+        IPackageCatalogAddResourcePackageResult(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalogAddResourcePackageResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalogRemoveOptionalPackagesResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalogRemoveOptionalPackagesResult>
+    {
+        IPackageCatalogRemoveOptionalPackagesResult(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalogRemoveOptionalPackagesResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalogRemoveResourcePackagesResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalogRemoveResourcePackagesResult>
+    {
+        IPackageCatalogRemoveResourcePackagesResult(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalogRemoveResourcePackagesResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageCatalogStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageCatalogStatics>
+    {
+        IPackageCatalogStatics(std::nullptr_t = nullptr) noexcept {}
+        IPackageCatalogStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageContentGroup :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageContentGroup>
+    {
+        IPackageContentGroup(std::nullptr_t = nullptr) noexcept {}
+        IPackageContentGroup(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageContentGroupStagingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageContentGroupStagingEventArgs>
+    {
+        IPackageContentGroupStagingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IPackageContentGroupStagingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageContentGroupStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageContentGroupStatics>
+    {
+        IPackageContentGroupStatics(std::nullptr_t = nullptr) noexcept {}
+        IPackageContentGroupStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageId :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageId>
+    {
+        IPackageId(std::nullptr_t = nullptr) noexcept {}
+        IPackageId(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageIdWithMetadata :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageIdWithMetadata>
+    {
+        IPackageIdWithMetadata(std::nullptr_t = nullptr) noexcept {}
+        IPackageIdWithMetadata(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageInstallingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageInstallingEventArgs>
+    {
+        IPackageInstallingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IPackageInstallingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageStagingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageStagingEventArgs>
+    {
+        IPackageStagingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IPackageStagingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageStatics>
+    {
+        IPackageStatics(std::nullptr_t = nullptr) noexcept {}
+        IPackageStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageStatus :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageStatus>
+    {
+        IPackageStatus(std::nullptr_t = nullptr) noexcept {}
+        IPackageStatus(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageStatus2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageStatus2>
+    {
+        IPackageStatus2(std::nullptr_t = nullptr) noexcept {}
+        IPackageStatus2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageStatusChangedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageStatusChangedEventArgs>
+    {
+        IPackageStatusChangedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IPackageStatusChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageUninstallingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageUninstallingEventArgs>
+    {
+        IPackageUninstallingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IPackageUninstallingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageUpdateAvailabilityResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageUpdateAvailabilityResult>
+    {
+        IPackageUpdateAvailabilityResult(std::nullptr_t = nullptr) noexcept {}
+        IPackageUpdateAvailabilityResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageUpdatingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageUpdatingEventArgs>
+    {
+        IPackageUpdatingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IPackageUpdatingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPackageWithMetadata :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPackageWithMetadata>
+    {
+        IPackageWithMetadata(std::nullptr_t = nullptr) noexcept {}
+        IPackageWithMetadata(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStartupTask :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStartupTask>
+    {
+        IStartupTask(std::nullptr_t = nullptr) noexcept {}
+        IStartupTask(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStartupTaskStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStartupTaskStatics>
+    {
+        IStartupTaskStatics(std::nullptr_t = nullptr) noexcept {}
+        IStartupTaskStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISuspendingDeferral :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISuspendingDeferral>
+    {
+        ISuspendingDeferral(std::nullptr_t = nullptr) noexcept {}
+        ISuspendingDeferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISuspendingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISuspendingEventArgs>
+    {
+        ISuspendingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        ISuspendingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISuspendingOperation :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISuspendingOperation>
+    {
+        ISuspendingOperation(std::nullptr_t = nullptr) noexcept {}
+        ISuspendingOperation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.ApplicationModel.2.h

@@ -0,0 +1,213 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_ApplicationModel_2_H
+#define WINRT_Windows_ApplicationModel_2_H
+#include "Windows.System.1.h"
+#include "Windows.ApplicationModel.1.h"
+namespace winrt::Windows::ApplicationModel
+{
+    struct PackageInstallProgress
+    {
+        uint32_t PercentComplete;
+    };
+    inline bool operator==(PackageInstallProgress const& left, PackageInstallProgress const& right) noexcept
+    {
+        return left.PercentComplete == right.PercentComplete;
+    }
+    inline bool operator!=(PackageInstallProgress const& left, PackageInstallProgress const& right) noexcept
+    {
+        return !(left == right);
+    }
+    struct PackageVersion
+    {
+        uint16_t Major;
+        uint16_t Minor;
+        uint16_t Build;
+        uint16_t Revision;
+    };
+    inline bool operator==(PackageVersion const& left, PackageVersion const& right) noexcept
+    {
+        return left.Major == right.Major && left.Minor == right.Minor && left.Build == right.Build && left.Revision == right.Revision;
+    }
+    inline bool operator!=(PackageVersion const& left, PackageVersion const& right) noexcept
+    {
+        return !(left == right);
+    }
+    struct __declspec(empty_bases) AppDisplayInfo : Windows::ApplicationModel::IAppDisplayInfo
+    {
+        AppDisplayInfo(std::nullptr_t) noexcept {}
+        AppDisplayInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IAppDisplayInfo(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppInfo : Windows::ApplicationModel::IAppInfo,
+        impl::require<AppInfo, Windows::ApplicationModel::IAppInfo2>
+    {
+        AppInfo(std::nullptr_t) noexcept {}
+        AppInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IAppInfo(ptr, take_ownership_from_abi) {}
+        [[nodiscard]] static auto Current();
+        static auto GetFromAppUserModelId(param::hstring const& appUserModelId);
+        static auto GetFromAppUserModelIdForUser(Windows::System::User const& user, param::hstring const& appUserModelId);
+    };
+    struct __declspec(empty_bases) AppInstallerInfo : Windows::ApplicationModel::IAppInstallerInfo
+    {
+        AppInstallerInfo(std::nullptr_t) noexcept {}
+        AppInstallerInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IAppInstallerInfo(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppInstance : Windows::ApplicationModel::IAppInstance
+    {
+        AppInstance(std::nullptr_t) noexcept {}
+        AppInstance(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IAppInstance(ptr, take_ownership_from_abi) {}
+        [[nodiscard]] static auto RecommendedInstance();
+        static auto GetActivatedEventArgs();
+        static auto FindOrRegisterInstanceForKey(param::hstring const& key);
+        static auto Unregister();
+        static auto GetInstances();
+    };
+    struct DesignMode
+    {
+        DesignMode() = delete;
+        [[nodiscard]] static auto DesignModeEnabled();
+        [[nodiscard]] static auto DesignMode2Enabled();
+    };
+    struct __declspec(empty_bases) EnteredBackgroundEventArgs : Windows::ApplicationModel::IEnteredBackgroundEventArgs
+    {
+        EnteredBackgroundEventArgs(std::nullptr_t) noexcept {}
+        EnteredBackgroundEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IEnteredBackgroundEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct FullTrustProcessLauncher
+    {
+        FullTrustProcessLauncher() = delete;
+        static auto LaunchFullTrustProcessForCurrentAppAsync();
+        static auto LaunchFullTrustProcessForCurrentAppAsync(param::hstring const& parameterGroupId);
+        static auto LaunchFullTrustProcessForAppAsync(param::hstring const& fullTrustPackageRelativeAppId);
+        static auto LaunchFullTrustProcessForAppAsync(param::hstring const& fullTrustPackageRelativeAppId, param::hstring const& parameterGroupId);
+    };
+    struct __declspec(empty_bases) LeavingBackgroundEventArgs : Windows::ApplicationModel::ILeavingBackgroundEventArgs
+    {
+        LeavingBackgroundEventArgs(std::nullptr_t) noexcept {}
+        LeavingBackgroundEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::ILeavingBackgroundEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) LimitedAccessFeatureRequestResult : Windows::ApplicationModel::ILimitedAccessFeatureRequestResult
+    {
+        LimitedAccessFeatureRequestResult(std::nullptr_t) noexcept {}
+        LimitedAccessFeatureRequestResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::ILimitedAccessFeatureRequestResult(ptr, take_ownership_from_abi) {}
+    };
+    struct LimitedAccessFeatures
+    {
+        LimitedAccessFeatures() = delete;
+        static auto TryUnlockFeature(param::hstring const& featureId, param::hstring const& token, param::hstring const& attestation);
+    };
+    struct __declspec(empty_bases) Package : Windows::ApplicationModel::IPackage,
+        impl::require<Package, Windows::ApplicationModel::IPackage2, Windows::ApplicationModel::IPackage3, Windows::ApplicationModel::IPackageWithMetadata, Windows::ApplicationModel::IPackage4, Windows::ApplicationModel::IPackage5, Windows::ApplicationModel::IPackage6, Windows::ApplicationModel::IPackage7, Windows::ApplicationModel::IPackage8>
+    {
+        Package(std::nullptr_t) noexcept {}
+        Package(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackage(ptr, take_ownership_from_abi) {}
+        [[nodiscard]] static auto Current();
+    };
+    struct __declspec(empty_bases) PackageCatalog : Windows::ApplicationModel::IPackageCatalog,
+        impl::require<PackageCatalog, Windows::ApplicationModel::IPackageCatalog2, Windows::ApplicationModel::IPackageCatalog3, Windows::ApplicationModel::IPackageCatalog4>
+    {
+        PackageCatalog(std::nullptr_t) noexcept {}
+        PackageCatalog(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageCatalog(ptr, take_ownership_from_abi) {}
+        static auto OpenForCurrentPackage();
+        static auto OpenForCurrentUser();
+    };
+    struct __declspec(empty_bases) PackageCatalogAddOptionalPackageResult : Windows::ApplicationModel::IPackageCatalogAddOptionalPackageResult
+    {
+        PackageCatalogAddOptionalPackageResult(std::nullptr_t) noexcept {}
+        PackageCatalogAddOptionalPackageResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageCatalogAddOptionalPackageResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageCatalogAddResourcePackageResult : Windows::ApplicationModel::IPackageCatalogAddResourcePackageResult
+    {
+        PackageCatalogAddResourcePackageResult(std::nullptr_t) noexcept {}
+        PackageCatalogAddResourcePackageResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageCatalogAddResourcePackageResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageCatalogRemoveOptionalPackagesResult : Windows::ApplicationModel::IPackageCatalogRemoveOptionalPackagesResult
+    {
+        PackageCatalogRemoveOptionalPackagesResult(std::nullptr_t) noexcept {}
+        PackageCatalogRemoveOptionalPackagesResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageCatalogRemoveOptionalPackagesResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageCatalogRemoveResourcePackagesResult : Windows::ApplicationModel::IPackageCatalogRemoveResourcePackagesResult
+    {
+        PackageCatalogRemoveResourcePackagesResult(std::nullptr_t) noexcept {}
+        PackageCatalogRemoveResourcePackagesResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageCatalogRemoveResourcePackagesResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageContentGroup : Windows::ApplicationModel::IPackageContentGroup
+    {
+        PackageContentGroup(std::nullptr_t) noexcept {}
+        PackageContentGroup(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageContentGroup(ptr, take_ownership_from_abi) {}
+        [[nodiscard]] static auto RequiredGroupName();
+    };
+    struct __declspec(empty_bases) PackageContentGroupStagingEventArgs : Windows::ApplicationModel::IPackageContentGroupStagingEventArgs
+    {
+        PackageContentGroupStagingEventArgs(std::nullptr_t) noexcept {}
+        PackageContentGroupStagingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageContentGroupStagingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageId : Windows::ApplicationModel::IPackageId,
+        impl::require<PackageId, Windows::ApplicationModel::IPackageIdWithMetadata>
+    {
+        PackageId(std::nullptr_t) noexcept {}
+        PackageId(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageId(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageInstallingEventArgs : Windows::ApplicationModel::IPackageInstallingEventArgs
+    {
+        PackageInstallingEventArgs(std::nullptr_t) noexcept {}
+        PackageInstallingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageInstallingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageStagingEventArgs : Windows::ApplicationModel::IPackageStagingEventArgs
+    {
+        PackageStagingEventArgs(std::nullptr_t) noexcept {}
+        PackageStagingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageStagingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageStatus : Windows::ApplicationModel::IPackageStatus,
+        impl::require<PackageStatus, Windows::ApplicationModel::IPackageStatus2>
+    {
+        PackageStatus(std::nullptr_t) noexcept {}
+        PackageStatus(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageStatus(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageStatusChangedEventArgs : Windows::ApplicationModel::IPackageStatusChangedEventArgs
+    {
+        PackageStatusChangedEventArgs(std::nullptr_t) noexcept {}
+        PackageStatusChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageStatusChangedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageUninstallingEventArgs : Windows::ApplicationModel::IPackageUninstallingEventArgs
+    {
+        PackageUninstallingEventArgs(std::nullptr_t) noexcept {}
+        PackageUninstallingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageUninstallingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageUpdateAvailabilityResult : Windows::ApplicationModel::IPackageUpdateAvailabilityResult
+    {
+        PackageUpdateAvailabilityResult(std::nullptr_t) noexcept {}
+        PackageUpdateAvailabilityResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageUpdateAvailabilityResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) PackageUpdatingEventArgs : Windows::ApplicationModel::IPackageUpdatingEventArgs
+    {
+        PackageUpdatingEventArgs(std::nullptr_t) noexcept {}
+        PackageUpdatingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IPackageUpdatingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StartupTask : Windows::ApplicationModel::IStartupTask
+    {
+        StartupTask(std::nullptr_t) noexcept {}
+        StartupTask(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::IStartupTask(ptr, take_ownership_from_abi) {}
+        static auto GetForCurrentPackageAsync();
+        static auto GetAsync(param::hstring const& taskId);
+    };
+    struct __declspec(empty_bases) SuspendingDeferral : Windows::ApplicationModel::ISuspendingDeferral
+    {
+        SuspendingDeferral(std::nullptr_t) noexcept {}
+        SuspendingDeferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::ISuspendingDeferral(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SuspendingEventArgs : Windows::ApplicationModel::ISuspendingEventArgs
+    {
+        SuspendingEventArgs(std::nullptr_t) noexcept {}
+        SuspendingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::ISuspendingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SuspendingOperation : Windows::ApplicationModel::ISuspendingOperation
+    {
+        SuspendingOperation(std::nullptr_t) noexcept {}
+        SuspendingOperation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::ApplicationModel::ISuspendingOperation(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Data.Xml.Dom.1.h

@@ -0,0 +1,190 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Data_Xml_Dom_1_H
+#define WINRT_Windows_Data_Xml_Dom_1_H
+#include "Windows.Foundation.Collections.0.h"
+#include "Windows.Data.Xml.Dom.0.h"
+namespace winrt::Windows::Data::Xml::Dom
+{
+    struct __declspec(empty_bases) IDtdEntity :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDtdEntity>,
+        impl::require<Windows::Data::Xml::Dom::IDtdEntity, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IDtdEntity(std::nullptr_t = nullptr) noexcept {}
+        IDtdEntity(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDtdNotation :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDtdNotation>,
+        impl::require<Windows::Data::Xml::Dom::IDtdNotation, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IDtdNotation(std::nullptr_t = nullptr) noexcept {}
+        IDtdNotation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlAttribute :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlAttribute>,
+        impl::require<Windows::Data::Xml::Dom::IXmlAttribute, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlAttribute(std::nullptr_t = nullptr) noexcept {}
+        IXmlAttribute(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlCDataSection :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlCDataSection>,
+        impl::require<Windows::Data::Xml::Dom::IXmlCDataSection, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode, Windows::Data::Xml::Dom::IXmlCharacterData, Windows::Data::Xml::Dom::IXmlText>
+    {
+        IXmlCDataSection(std::nullptr_t = nullptr) noexcept {}
+        IXmlCDataSection(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlCharacterData :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlCharacterData>,
+        impl::require<Windows::Data::Xml::Dom::IXmlCharacterData, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlCharacterData(std::nullptr_t = nullptr) noexcept {}
+        IXmlCharacterData(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlComment :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlComment>,
+        impl::require<Windows::Data::Xml::Dom::IXmlComment, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode, Windows::Data::Xml::Dom::IXmlCharacterData>
+    {
+        IXmlComment(std::nullptr_t = nullptr) noexcept {}
+        IXmlComment(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlDocument :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlDocument>,
+        impl::require<Windows::Data::Xml::Dom::IXmlDocument, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlDocument(std::nullptr_t = nullptr) noexcept {}
+        IXmlDocument(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlDocumentFragment :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlDocumentFragment>,
+        impl::require<Windows::Data::Xml::Dom::IXmlDocumentFragment, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlDocumentFragment(std::nullptr_t = nullptr) noexcept {}
+        IXmlDocumentFragment(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlDocumentIO :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlDocumentIO>
+    {
+        IXmlDocumentIO(std::nullptr_t = nullptr) noexcept {}
+        IXmlDocumentIO(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlDocumentIO2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlDocumentIO2>
+    {
+        IXmlDocumentIO2(std::nullptr_t = nullptr) noexcept {}
+        IXmlDocumentIO2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlDocumentStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlDocumentStatics>
+    {
+        IXmlDocumentStatics(std::nullptr_t = nullptr) noexcept {}
+        IXmlDocumentStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlDocumentType :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlDocumentType>,
+        impl::require<Windows::Data::Xml::Dom::IXmlDocumentType, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlDocumentType(std::nullptr_t = nullptr) noexcept {}
+        IXmlDocumentType(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlDomImplementation :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlDomImplementation>
+    {
+        IXmlDomImplementation(std::nullptr_t = nullptr) noexcept {}
+        IXmlDomImplementation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlElement :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlElement>,
+        impl::require<Windows::Data::Xml::Dom::IXmlElement, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlElement(std::nullptr_t = nullptr) noexcept {}
+        IXmlElement(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlEntityReference :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlEntityReference>,
+        impl::require<Windows::Data::Xml::Dom::IXmlEntityReference, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlEntityReference(std::nullptr_t = nullptr) noexcept {}
+        IXmlEntityReference(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlLoadSettings :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlLoadSettings>
+    {
+        IXmlLoadSettings(std::nullptr_t = nullptr) noexcept {}
+        IXmlLoadSettings(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlNamedNodeMap :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlNamedNodeMap>,
+        impl::require<Windows::Data::Xml::Dom::IXmlNamedNodeMap, Windows::Foundation::Collections::IIterable<Windows::Data::Xml::Dom::IXmlNode>, Windows::Foundation::Collections::IVectorView<Windows::Data::Xml::Dom::IXmlNode>>
+    {
+        IXmlNamedNodeMap(std::nullptr_t = nullptr) noexcept {}
+        IXmlNamedNodeMap(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlNode :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlNode>,
+        impl::require<Windows::Data::Xml::Dom::IXmlNode, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer>
+    {
+        IXmlNode(std::nullptr_t = nullptr) noexcept {}
+        IXmlNode(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlNodeList :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlNodeList>,
+        impl::require<Windows::Data::Xml::Dom::IXmlNodeList, Windows::Foundation::Collections::IIterable<Windows::Data::Xml::Dom::IXmlNode>, Windows::Foundation::Collections::IVectorView<Windows::Data::Xml::Dom::IXmlNode>>
+    {
+        IXmlNodeList(std::nullptr_t = nullptr) noexcept {}
+        IXmlNodeList(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlNodeSelector :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlNodeSelector>
+    {
+        IXmlNodeSelector(std::nullptr_t = nullptr) noexcept {}
+        IXmlNodeSelector(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlNodeSerializer :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlNodeSerializer>
+    {
+        IXmlNodeSerializer(std::nullptr_t = nullptr) noexcept {}
+        IXmlNodeSerializer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlProcessingInstruction :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlProcessingInstruction>,
+        impl::require<Windows::Data::Xml::Dom::IXmlProcessingInstruction, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode>
+    {
+        IXmlProcessingInstruction(std::nullptr_t = nullptr) noexcept {}
+        IXmlProcessingInstruction(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IXmlText :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IXmlText>,
+        impl::require<Windows::Data::Xml::Dom::IXmlText, Windows::Data::Xml::Dom::IXmlNodeSelector, Windows::Data::Xml::Dom::IXmlNodeSerializer, Windows::Data::Xml::Dom::IXmlNode, Windows::Data::Xml::Dom::IXmlCharacterData>
+    {
+        IXmlText(std::nullptr_t = nullptr) noexcept {}
+        IXmlText(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Data.Xml.Dom.2.h

@@ -0,0 +1,102 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Data_Xml_Dom_2_H
+#define WINRT_Windows_Data_Xml_Dom_2_H
+#include "Windows.Foundation.1.h"
+#include "Windows.Foundation.Collections.1.h"
+#include "Windows.Storage.1.h"
+#include "Windows.Data.Xml.Dom.1.h"
+namespace winrt::Windows::Data::Xml::Dom
+{
+    struct __declspec(empty_bases) DtdEntity : Windows::Data::Xml::Dom::IDtdEntity
+    {
+        DtdEntity(std::nullptr_t) noexcept {}
+        DtdEntity(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IDtdEntity(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) DtdNotation : Windows::Data::Xml::Dom::IDtdNotation
+    {
+        DtdNotation(std::nullptr_t) noexcept {}
+        DtdNotation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IDtdNotation(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlAttribute : Windows::Data::Xml::Dom::IXmlAttribute
+    {
+        XmlAttribute(std::nullptr_t) noexcept {}
+        XmlAttribute(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlAttribute(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlCDataSection : Windows::Data::Xml::Dom::IXmlCDataSection
+    {
+        XmlCDataSection(std::nullptr_t) noexcept {}
+        XmlCDataSection(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlCDataSection(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlComment : Windows::Data::Xml::Dom::IXmlComment
+    {
+        XmlComment(std::nullptr_t) noexcept {}
+        XmlComment(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlComment(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlDocument : Windows::Data::Xml::Dom::IXmlDocument,
+        impl::require<XmlDocument, Windows::Data::Xml::Dom::IXmlDocumentIO, Windows::Data::Xml::Dom::IXmlDocumentIO2>
+    {
+        XmlDocument(std::nullptr_t) noexcept {}
+        XmlDocument(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlDocument(ptr, take_ownership_from_abi) {}
+        XmlDocument();
+        static auto LoadFromUriAsync(Windows::Foundation::Uri const& uri);
+        static auto LoadFromUriAsync(Windows::Foundation::Uri const& uri, Windows::Data::Xml::Dom::XmlLoadSettings const& loadSettings);
+        static auto LoadFromFileAsync(Windows::Storage::IStorageFile const& file);
+        static auto LoadFromFileAsync(Windows::Storage::IStorageFile const& file, Windows::Data::Xml::Dom::XmlLoadSettings const& loadSettings);
+    };
+    struct __declspec(empty_bases) XmlDocumentFragment : Windows::Data::Xml::Dom::IXmlDocumentFragment
+    {
+        XmlDocumentFragment(std::nullptr_t) noexcept {}
+        XmlDocumentFragment(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlDocumentFragment(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlDocumentType : Windows::Data::Xml::Dom::IXmlDocumentType
+    {
+        XmlDocumentType(std::nullptr_t) noexcept {}
+        XmlDocumentType(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlDocumentType(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlDomImplementation : Windows::Data::Xml::Dom::IXmlDomImplementation
+    {
+        XmlDomImplementation(std::nullptr_t) noexcept {}
+        XmlDomImplementation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlDomImplementation(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlElement : Windows::Data::Xml::Dom::IXmlElement
+    {
+        XmlElement(std::nullptr_t) noexcept {}
+        XmlElement(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlElement(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlEntityReference : Windows::Data::Xml::Dom::IXmlEntityReference
+    {
+        XmlEntityReference(std::nullptr_t) noexcept {}
+        XmlEntityReference(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlEntityReference(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlLoadSettings : Windows::Data::Xml::Dom::IXmlLoadSettings
+    {
+        XmlLoadSettings(std::nullptr_t) noexcept {}
+        XmlLoadSettings(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlLoadSettings(ptr, take_ownership_from_abi) {}
+        XmlLoadSettings();
+    };
+    struct __declspec(empty_bases) XmlNamedNodeMap : Windows::Data::Xml::Dom::IXmlNamedNodeMap
+    {
+        XmlNamedNodeMap(std::nullptr_t) noexcept {}
+        XmlNamedNodeMap(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlNamedNodeMap(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlNodeList : Windows::Data::Xml::Dom::IXmlNodeList
+    {
+        XmlNodeList(std::nullptr_t) noexcept {}
+        XmlNodeList(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlNodeList(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlProcessingInstruction : Windows::Data::Xml::Dom::IXmlProcessingInstruction
+    {
+        XmlProcessingInstruction(std::nullptr_t) noexcept {}
+        XmlProcessingInstruction(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlProcessingInstruction(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) XmlText : Windows::Data::Xml::Dom::IXmlText
+    {
+        XmlText(std::nullptr_t) noexcept {}
+        XmlText(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Data::Xml::Dom::IXmlText(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Foundation.1.h

@@ -0,0 +1,218 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Foundation_1_H
+#define WINRT_Windows_Foundation_1_H
+#include "Windows.Foundation.Collections.0.h"
+#include "Windows.Foundation.0.h"
+namespace winrt::Windows::Foundation
+{
+    struct __declspec(empty_bases) IAsyncAction :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAsyncAction>,
+        impl::require<Windows::Foundation::IAsyncAction, Windows::Foundation::IAsyncInfo>
+    {
+        IAsyncAction(std::nullptr_t = nullptr) noexcept {}
+        IAsyncAction(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename TProgress>
+    struct __declspec(empty_bases) IAsyncActionWithProgress :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::IAsyncActionWithProgress<TProgress>>,
+        impl::require<Windows::Foundation::IAsyncActionWithProgress<TProgress>, Windows::Foundation::IAsyncInfo>
+    {
+        static_assert(impl::has_category_v<TProgress>, "TProgress must be WinRT type.");
+        IAsyncActionWithProgress(std::nullptr_t = nullptr) noexcept {}
+        IAsyncActionWithProgress(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAsyncInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAsyncInfo>
+    {
+        IAsyncInfo(std::nullptr_t = nullptr) noexcept {}
+        IAsyncInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename TResult, typename TProgress>
+    struct __declspec(empty_bases) IAsyncOperationWithProgress :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::IAsyncOperationWithProgress<TResult, TProgress>>,
+        impl::require<Windows::Foundation::IAsyncOperationWithProgress<TResult, TProgress>, Windows::Foundation::IAsyncInfo>
+    {
+        static_assert(impl::has_category_v<TResult>, "TResult must be WinRT type.");
+        static_assert(impl::has_category_v<TProgress>, "TProgress must be WinRT type.");
+        IAsyncOperationWithProgress(std::nullptr_t = nullptr) noexcept {}
+        IAsyncOperationWithProgress(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename TResult>
+    struct __declspec(empty_bases) IAsyncOperation :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::IAsyncOperation<TResult>>,
+        impl::require<Windows::Foundation::IAsyncOperation<TResult>, Windows::Foundation::IAsyncInfo>
+    {
+        static_assert(impl::has_category_v<TResult>, "TResult must be WinRT type.");
+        IAsyncOperation(std::nullptr_t = nullptr) noexcept {}
+        IAsyncOperation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IClosable :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IClosable>
+    {
+        IClosable(std::nullptr_t = nullptr) noexcept {}
+        IClosable(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDeferral :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDeferral>,
+        impl::require<Windows::Foundation::IDeferral, Windows::Foundation::IClosable>
+    {
+        IDeferral(std::nullptr_t = nullptr) noexcept {}
+        IDeferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDeferralFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDeferralFactory>
+    {
+        IDeferralFactory(std::nullptr_t = nullptr) noexcept {}
+        IDeferralFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IGetActivationFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IGetActivationFactory>
+    {
+        IGetActivationFactory(std::nullptr_t = nullptr) noexcept {}
+        IGetActivationFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IGuidHelperStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IGuidHelperStatics>
+    {
+        IGuidHelperStatics(std::nullptr_t = nullptr) noexcept {}
+        IGuidHelperStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IMemoryBuffer :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IMemoryBuffer>,
+        impl::require<Windows::Foundation::IMemoryBuffer, Windows::Foundation::IClosable>
+    {
+        IMemoryBuffer(std::nullptr_t = nullptr) noexcept {}
+        IMemoryBuffer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IMemoryBufferFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IMemoryBufferFactory>
+    {
+        IMemoryBufferFactory(std::nullptr_t = nullptr) noexcept {}
+        IMemoryBufferFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IMemoryBufferReference :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IMemoryBufferReference>,
+        impl::require<Windows::Foundation::IMemoryBufferReference, Windows::Foundation::IClosable>
+    {
+        IMemoryBufferReference(std::nullptr_t = nullptr) noexcept {}
+        IMemoryBufferReference(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPropertyValue :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPropertyValue>
+    {
+        IPropertyValue(std::nullptr_t = nullptr) noexcept {}
+        IPropertyValue(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPropertyValueStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPropertyValueStatics>
+    {
+        IPropertyValueStatics(std::nullptr_t = nullptr) noexcept {}
+        IPropertyValueStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename T>
+    struct __declspec(empty_bases) IReferenceArray :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::IReferenceArray<T>>,
+        impl::require<Windows::Foundation::IReferenceArray<T>, Windows::Foundation::IPropertyValue>
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        IReferenceArray(std::nullptr_t = nullptr) noexcept {}
+        IReferenceArray(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename T>
+    struct __declspec(empty_bases) IReference :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::IReference<T>>,
+        impl::require<Windows::Foundation::IReference<T>, Windows::Foundation::IPropertyValue>
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        IReference(std::nullptr_t = nullptr) noexcept {}
+        IReference(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+        IReference(T const& value) : IReference<T>(impl::reference_traits<T>::make(value))
+        {
+        }
+
+    private:
+
+        IReference<T>(IInspectable const& value) : IReference<T>(value.as<IReference<T>>())
+        {
+        }
+    };
+    struct __declspec(empty_bases) IStringable :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStringable>
+    {
+        IStringable(std::nullptr_t = nullptr) noexcept {}
+        IStringable(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUriEscapeStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUriEscapeStatics>
+    {
+        IUriEscapeStatics(std::nullptr_t = nullptr) noexcept {}
+        IUriEscapeStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUriRuntimeClass :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUriRuntimeClass>
+    {
+        IUriRuntimeClass(std::nullptr_t = nullptr) noexcept {}
+        IUriRuntimeClass(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUriRuntimeClassFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUriRuntimeClassFactory>
+    {
+        IUriRuntimeClassFactory(std::nullptr_t = nullptr) noexcept {}
+        IUriRuntimeClassFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUriRuntimeClassWithAbsoluteCanonicalUri :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUriRuntimeClassWithAbsoluteCanonicalUri>
+    {
+        IUriRuntimeClassWithAbsoluteCanonicalUri(std::nullptr_t = nullptr) noexcept {}
+        IUriRuntimeClassWithAbsoluteCanonicalUri(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IWwwFormUrlDecoderEntry :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IWwwFormUrlDecoderEntry>
+    {
+        IWwwFormUrlDecoderEntry(std::nullptr_t = nullptr) noexcept {}
+        IWwwFormUrlDecoderEntry(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IWwwFormUrlDecoderRuntimeClass :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IWwwFormUrlDecoderRuntimeClass>,
+        impl::require<Windows::Foundation::IWwwFormUrlDecoderRuntimeClass, Windows::Foundation::Collections::IIterable<Windows::Foundation::IWwwFormUrlDecoderEntry>, Windows::Foundation::Collections::IVectorView<Windows::Foundation::IWwwFormUrlDecoderEntry>>
+    {
+        IWwwFormUrlDecoderRuntimeClass(std::nullptr_t = nullptr) noexcept {}
+        IWwwFormUrlDecoderRuntimeClass(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IWwwFormUrlDecoderRuntimeClassFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IWwwFormUrlDecoderRuntimeClassFactory>
+    {
+        IWwwFormUrlDecoderRuntimeClassFactory(std::nullptr_t = nullptr) noexcept {}
+        IWwwFormUrlDecoderRuntimeClassFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Foundation.2.h

@@ -0,0 +1,212 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Foundation_2_H
+#define WINRT_Windows_Foundation_2_H
+#include "Windows.Foundation.Collections.1.h"
+#include "Windows.Foundation.1.h"
+namespace winrt::Windows::Foundation
+{
+    struct AsyncActionCompletedHandler : Windows::Foundation::IUnknown
+    {
+        AsyncActionCompletedHandler(std::nullptr_t = nullptr) noexcept {}
+        AsyncActionCompletedHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> AsyncActionCompletedHandler(L lambda);
+        template <typename F> AsyncActionCompletedHandler(F* function);
+        template <typename O, typename M> AsyncActionCompletedHandler(O* object, M method);
+        template <typename O, typename M> AsyncActionCompletedHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> AsyncActionCompletedHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::IAsyncAction const& asyncInfo, Windows::Foundation::AsyncStatus const& asyncStatus) const;
+    };
+    template <typename TProgress>
+    struct AsyncActionProgressHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<TProgress>, "TProgress must be WinRT type.");
+        AsyncActionProgressHandler(std::nullptr_t = nullptr) noexcept {}
+        AsyncActionProgressHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> AsyncActionProgressHandler(L lambda);
+        template <typename F> AsyncActionProgressHandler(F* function);
+        template <typename O, typename M> AsyncActionProgressHandler(O* object, M method);
+        template <typename O, typename M> AsyncActionProgressHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> AsyncActionProgressHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::IAsyncActionWithProgress<TProgress> const& asyncInfo, impl::param_type<TProgress> const& progressInfo) const;
+    };
+    template <typename TProgress>
+    struct AsyncActionWithProgressCompletedHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<TProgress>, "TProgress must be WinRT type.");
+        AsyncActionWithProgressCompletedHandler(std::nullptr_t = nullptr) noexcept {}
+        AsyncActionWithProgressCompletedHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> AsyncActionWithProgressCompletedHandler(L lambda);
+        template <typename F> AsyncActionWithProgressCompletedHandler(F* function);
+        template <typename O, typename M> AsyncActionWithProgressCompletedHandler(O* object, M method);
+        template <typename O, typename M> AsyncActionWithProgressCompletedHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> AsyncActionWithProgressCompletedHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::IAsyncActionWithProgress<TProgress> const& asyncInfo, Windows::Foundation::AsyncStatus const& asyncStatus) const;
+    };
+    template <typename TResult>
+    struct AsyncOperationCompletedHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<TResult>, "TResult must be WinRT type.");
+        AsyncOperationCompletedHandler(std::nullptr_t = nullptr) noexcept {}
+        AsyncOperationCompletedHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> AsyncOperationCompletedHandler(L lambda);
+        template <typename F> AsyncOperationCompletedHandler(F* function);
+        template <typename O, typename M> AsyncOperationCompletedHandler(O* object, M method);
+        template <typename O, typename M> AsyncOperationCompletedHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> AsyncOperationCompletedHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::IAsyncOperation<TResult> const& asyncInfo, Windows::Foundation::AsyncStatus const& asyncStatus) const;
+    };
+    template <typename TResult, typename TProgress>
+    struct AsyncOperationProgressHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<TResult>, "TResult must be WinRT type.");
+        static_assert(impl::has_category_v<TProgress>, "TProgress must be WinRT type.");
+        AsyncOperationProgressHandler(std::nullptr_t = nullptr) noexcept {}
+        AsyncOperationProgressHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> AsyncOperationProgressHandler(L lambda);
+        template <typename F> AsyncOperationProgressHandler(F* function);
+        template <typename O, typename M> AsyncOperationProgressHandler(O* object, M method);
+        template <typename O, typename M> AsyncOperationProgressHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> AsyncOperationProgressHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::IAsyncOperationWithProgress<TResult, TProgress> const& asyncInfo, impl::param_type<TProgress> const& progressInfo) const;
+    };
+    template <typename TResult, typename TProgress>
+    struct AsyncOperationWithProgressCompletedHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<TResult>, "TResult must be WinRT type.");
+        static_assert(impl::has_category_v<TProgress>, "TProgress must be WinRT type.");
+        AsyncOperationWithProgressCompletedHandler(std::nullptr_t = nullptr) noexcept {}
+        AsyncOperationWithProgressCompletedHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> AsyncOperationWithProgressCompletedHandler(L lambda);
+        template <typename F> AsyncOperationWithProgressCompletedHandler(F* function);
+        template <typename O, typename M> AsyncOperationWithProgressCompletedHandler(O* object, M method);
+        template <typename O, typename M> AsyncOperationWithProgressCompletedHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> AsyncOperationWithProgressCompletedHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::IAsyncOperationWithProgress<TResult, TProgress> const& asyncInfo, Windows::Foundation::AsyncStatus const& asyncStatus) const;
+    };
+    struct DeferralCompletedHandler : Windows::Foundation::IUnknown
+    {
+        DeferralCompletedHandler(std::nullptr_t = nullptr) noexcept {}
+        DeferralCompletedHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> DeferralCompletedHandler(L lambda);
+        template <typename F> DeferralCompletedHandler(F* function);
+        template <typename O, typename M> DeferralCompletedHandler(O* object, M method);
+        template <typename O, typename M> DeferralCompletedHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> DeferralCompletedHandler(weak_ref<O>&& object, M method);
+        auto operator()() const;
+    };
+    template <typename T>
+    struct EventHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        EventHandler(std::nullptr_t = nullptr) noexcept {}
+        EventHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> EventHandler(L lambda);
+        template <typename F> EventHandler(F* function);
+        template <typename O, typename M> EventHandler(O* object, M method);
+        template <typename O, typename M> EventHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> EventHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::IInspectable const& sender, impl::param_type<T> const& args) const;
+    };
+    template <typename TSender, typename TResult>
+    struct TypedEventHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<TSender>, "TSender must be WinRT type.");
+        static_assert(impl::has_category_v<TResult>, "TResult must be WinRT type.");
+        TypedEventHandler(std::nullptr_t = nullptr) noexcept {}
+        TypedEventHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> TypedEventHandler(L lambda);
+        template <typename F> TypedEventHandler(F* function);
+        template <typename O, typename M> TypedEventHandler(O* object, M method);
+        template <typename O, typename M> TypedEventHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> TypedEventHandler(weak_ref<O>&& object, M method);
+        auto operator()(impl::param_type<TSender> const& sender, impl::param_type<TResult> const& args) const;
+    };
+    struct __declspec(empty_bases) Deferral : Windows::Foundation::IDeferral
+    {
+        Deferral(std::nullptr_t) noexcept {}
+        Deferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IDeferral(ptr, take_ownership_from_abi) {}
+        Deferral(Windows::Foundation::DeferralCompletedHandler const& handler);
+    };
+    struct GuidHelper
+    {
+        GuidHelper() = delete;
+        static auto CreateNewGuid();
+        [[nodiscard]] static auto Empty();
+        static auto Equals(winrt::guid const& target, winrt::guid const& value);
+    };
+    struct __declspec(empty_bases) MemoryBuffer : Windows::Foundation::IMemoryBuffer
+    {
+        MemoryBuffer(std::nullptr_t) noexcept {}
+        MemoryBuffer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IMemoryBuffer(ptr, take_ownership_from_abi) {}
+        MemoryBuffer(uint32_t capacity);
+    };
+    struct PropertyValue
+    {
+        PropertyValue() = delete;
+        static auto CreateEmpty();
+        static auto CreateUInt8(uint8_t value);
+        static auto CreateInt16(int16_t value);
+        static auto CreateUInt16(uint16_t value);
+        static auto CreateInt32(int32_t value);
+        static auto CreateUInt32(uint32_t value);
+        static auto CreateInt64(int64_t value);
+        static auto CreateUInt64(uint64_t value);
+        static auto CreateSingle(float value);
+        static auto CreateDouble(double value);
+        static auto CreateChar16(char16_t value);
+        static auto CreateBoolean(bool value);
+        static auto CreateString(param::hstring const& value);
+        static auto CreateInspectable(Windows::Foundation::IInspectable const& value);
+        static auto CreateGuid(winrt::guid const& value);
+        static auto CreateDateTime(Windows::Foundation::DateTime const& value);
+        static auto CreateTimeSpan(Windows::Foundation::TimeSpan const& value);
+        static auto CreatePoint(Windows::Foundation::Point const& value);
+        static auto CreateSize(Windows::Foundation::Size const& value);
+        static auto CreateRect(Windows::Foundation::Rect const& value);
+        static auto CreateUInt8Array(array_view<uint8_t const> value);
+        static auto CreateInt16Array(array_view<int16_t const> value);
+        static auto CreateUInt16Array(array_view<uint16_t const> value);
+        static auto CreateInt32Array(array_view<int32_t const> value);
+        static auto CreateUInt32Array(array_view<uint32_t const> value);
+        static auto CreateInt64Array(array_view<int64_t const> value);
+        static auto CreateUInt64Array(array_view<uint64_t const> value);
+        static auto CreateSingleArray(array_view<float const> value);
+        static auto CreateDoubleArray(array_view<double const> value);
+        static auto CreateChar16Array(array_view<char16_t const> value);
+        static auto CreateBooleanArray(array_view<bool const> value);
+        static auto CreateStringArray(array_view<hstring const> value);
+        static auto CreateInspectableArray(array_view<Windows::Foundation::IInspectable const> value);
+        static auto CreateGuidArray(array_view<winrt::guid const> value);
+        static auto CreateDateTimeArray(array_view<Windows::Foundation::DateTime const> value);
+        static auto CreateTimeSpanArray(array_view<Windows::Foundation::TimeSpan const> value);
+        static auto CreatePointArray(array_view<Windows::Foundation::Point const> value);
+        static auto CreateSizeArray(array_view<Windows::Foundation::Size const> value);
+        static auto CreateRectArray(array_view<Windows::Foundation::Rect const> value);
+    };
+    struct __declspec(empty_bases) Uri : Windows::Foundation::IUriRuntimeClass,
+        impl::require<Uri, Windows::Foundation::IUriRuntimeClassWithAbsoluteCanonicalUri, Windows::Foundation::IStringable>
+    {
+        Uri(std::nullptr_t) noexcept {}
+        Uri(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUriRuntimeClass(ptr, take_ownership_from_abi) {}
+        Uri(param::hstring const& uri);
+        Uri(param::hstring const& baseUri, param::hstring const& relativeUri);
+        static auto UnescapeComponent(param::hstring const& toUnescape);
+        static auto EscapeComponent(param::hstring const& toEscape);
+    };
+    struct __declspec(empty_bases) WwwFormUrlDecoder : Windows::Foundation::IWwwFormUrlDecoderRuntimeClass
+    {
+        WwwFormUrlDecoder(std::nullptr_t) noexcept {}
+        WwwFormUrlDecoder(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IWwwFormUrlDecoderRuntimeClass(ptr, take_ownership_from_abi) {}
+        WwwFormUrlDecoder(param::hstring const& query);
+    };
+    struct __declspec(empty_bases) WwwFormUrlDecoderEntry : Windows::Foundation::IWwwFormUrlDecoderEntry
+    {
+        WwwFormUrlDecoderEntry(std::nullptr_t) noexcept {}
+        WwwFormUrlDecoderEntry(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IWwwFormUrlDecoderEntry(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Foundation.Collections.0.h

@@ -0,0 +1,605 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Foundation_Collections_0_H
+#define WINRT_Windows_Foundation_Collections_0_H
+namespace winrt::Windows::Foundation
+{
+    struct EventRegistrationToken;
+}
+namespace winrt::Windows::Foundation::Collections
+{
+    enum class CollectionChange : int32_t
+    {
+        Reset = 0,
+        ItemInserted = 1,
+        ItemRemoved = 2,
+        ItemChanged = 3,
+    };
+    template <typename T> struct IIterable;
+    template <typename T> struct IIterator;
+    template <typename K, typename V> struct IKeyValuePair;
+    template <typename K> struct IMapChangedEventArgs;
+    template <typename K, typename V> struct IMapView;
+    template <typename K, typename V> struct IMap;
+    template <typename K, typename V> struct IObservableMap;
+    template <typename T> struct IObservableVector;
+    struct IPropertySet;
+    struct IVectorChangedEventArgs;
+    template <typename T> struct IVectorView;
+    template <typename T> struct IVector;
+    struct PropertySet;
+    struct StringMap;
+    struct ValueSet;
+    template <typename K, typename V> struct MapChangedEventHandler;
+    template <typename T> struct VectorChangedEventHandler;
+}
+namespace winrt::impl
+{
+    template <typename T> struct category<Windows::Foundation::Collections::IIterable<T>>
+    {
+        using type = pinterface_category<T>;
+        static constexpr guid value{ 0xFAA585EA,0x6214,0x4217,{ 0xAF,0xDA,0x7F,0x46,0xDE,0x58,0x69,0xB3 } };
+    };
+    template <typename T> struct category<Windows::Foundation::Collections::IIterator<T>>
+    {
+        using type = pinterface_category<T>;
+        static constexpr guid value{ 0x6A79E863,0x4300,0x459A,{ 0x99,0x66,0xCB,0xB6,0x60,0x96,0x3E,0xE1 } };
+    };
+    template <typename K, typename V> struct category<Windows::Foundation::Collections::IKeyValuePair<K, V>>
+    {
+        using type = pinterface_category<K, V>;
+        static constexpr guid value{ 0x02B51929,0xC1C4,0x4A7E,{ 0x89,0x40,0x03,0x12,0xB5,0xC1,0x85,0x00 } };
+    };
+    template <typename K> struct category<Windows::Foundation::Collections::IMapChangedEventArgs<K>>
+    {
+        using type = pinterface_category<K>;
+        static constexpr guid value{ 0x9939F4DF,0x050A,0x4C0F,{ 0xAA,0x60,0x77,0x07,0x5F,0x9C,0x47,0x77 } };
+    };
+    template <typename K, typename V> struct category<Windows::Foundation::Collections::IMapView<K, V>>
+    {
+        using type = pinterface_category<K, V>;
+        static constexpr guid value{ 0xE480CE40,0xA338,0x4ADA,{ 0xAD,0xCF,0x27,0x22,0x72,0xE4,0x8C,0xB9 } };
+    };
+    template <typename K, typename V> struct category<Windows::Foundation::Collections::IMap<K, V>>
+    {
+        using type = pinterface_category<K, V>;
+        static constexpr guid value{ 0x3C2925FE,0x8519,0x45C1,{ 0xAA,0x79,0x19,0x7B,0x67,0x18,0xC1,0xC1 } };
+    };
+    template <typename K, typename V> struct category<Windows::Foundation::Collections::IObservableMap<K, V>>
+    {
+        using type = pinterface_category<K, V>;
+        static constexpr guid value{ 0x65DF2BF5,0xBF39,0x41B5,{ 0xAE,0xBC,0x5A,0x9D,0x86,0x5E,0x47,0x2B } };
+    };
+    template <typename T> struct category<Windows::Foundation::Collections::IObservableVector<T>>
+    {
+        using type = pinterface_category<T>;
+        static constexpr guid value{ 0x5917EB53,0x50B4,0x4A0D,{ 0xB3,0x09,0x65,0x86,0x2B,0x3F,0x1D,0xBC } };
+    };
+    template <> struct category<Windows::Foundation::Collections::IPropertySet>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Foundation::Collections::IVectorChangedEventArgs>
+    {
+        using type = interface_category;
+    };
+    template <typename T> struct category<Windows::Foundation::Collections::IVectorView<T>>
+    {
+        using type = pinterface_category<T>;
+        static constexpr guid value{ 0xBBE1FA4C,0xB0E3,0x4583,{ 0xBA,0xEF,0x1F,0x1B,0x2E,0x48,0x3E,0x56 } };
+    };
+    template <typename T> struct category<Windows::Foundation::Collections::IVector<T>>
+    {
+        using type = pinterface_category<T>;
+        static constexpr guid value{ 0x913337E9,0x11A1,0x4345,{ 0xA3,0xA2,0x4E,0x7F,0x95,0x6E,0x22,0x2D } };
+    };
+    template <> struct category<Windows::Foundation::Collections::PropertySet>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Foundation::Collections::StringMap>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Foundation::Collections::ValueSet>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Foundation::Collections::CollectionChange>
+    {
+        using type = enum_category;
+    };
+    template <typename K, typename V> struct category<Windows::Foundation::Collections::MapChangedEventHandler<K, V>>
+    {
+        using type = pinterface_category<K, V>;
+        static constexpr guid value{ 0x179517F3,0x94EE,0x41F8,{ 0xBD,0xDC,0x76,0x8A,0x89,0x55,0x44,0xF3 } };
+    };
+    template <typename T> struct category<Windows::Foundation::Collections::VectorChangedEventHandler<T>>
+    {
+        using type = pinterface_category<T>;
+        static constexpr guid value{ 0x0C051752,0x9FBF,0x4C70,{ 0xAA,0x0C,0x0E,0x4C,0x82,0xD9,0xA7,0x61 } };
+    };
+    template <typename T> struct name<Windows::Foundation::Collections::IIterable<T>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IIterable`1<", name_v<T>, L">") };
+    };
+    template <typename T> struct name<Windows::Foundation::Collections::IIterator<T>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IIterator`1<", name_v<T>, L">") };
+    };
+    template <typename K, typename V> struct name<Windows::Foundation::Collections::IKeyValuePair<K, V>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IKeyValuePair`2<", name_v<K>, L", ", name_v<V>, L">") };
+    };
+    template <typename K> struct name<Windows::Foundation::Collections::IMapChangedEventArgs<K>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IMapChangedEventArgs`1<", name_v<K>, L">") };
+    };
+    template <typename K, typename V> struct name<Windows::Foundation::Collections::IMapView<K, V>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IMapView`2<", name_v<K>, L", ", name_v<V>, L">") };
+    };
+    template <typename K, typename V> struct name<Windows::Foundation::Collections::IMap<K, V>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IMap`2<", name_v<K>, L", ", name_v<V>, L">") };
+    };
+    template <typename K, typename V> struct name<Windows::Foundation::Collections::IObservableMap<K, V>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IObservableMap`2<", name_v<K>, L", ", name_v<V>, L">") };
+    };
+    template <typename T> struct name<Windows::Foundation::Collections::IObservableVector<T>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IObservableVector`1<", name_v<T>, L">") };
+    };
+    template <> struct name<Windows::Foundation::Collections::IPropertySet>
+    {
+        static constexpr auto & value{ L"Windows.Foundation.Collections.IPropertySet" };
+    };
+    template <> struct name<Windows::Foundation::Collections::IVectorChangedEventArgs>
+    {
+        static constexpr auto & value{ L"Windows.Foundation.Collections.IVectorChangedEventArgs" };
+    };
+    template <typename T> struct name<Windows::Foundation::Collections::IVectorView<T>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IVectorView`1<", name_v<T>, L">") };
+    };
+    template <typename T> struct name<Windows::Foundation::Collections::IVector<T>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.IVector`1<", name_v<T>, L">") };
+    };
+    template <> struct name<Windows::Foundation::Collections::PropertySet>
+    {
+        static constexpr auto & value{ L"Windows.Foundation.Collections.PropertySet" };
+    };
+    template <> struct name<Windows::Foundation::Collections::StringMap>
+    {
+        static constexpr auto & value{ L"Windows.Foundation.Collections.StringMap" };
+    };
+    template <> struct name<Windows::Foundation::Collections::ValueSet>
+    {
+        static constexpr auto & value{ L"Windows.Foundation.Collections.ValueSet" };
+    };
+    template <> struct name<Windows::Foundation::Collections::CollectionChange>
+    {
+        static constexpr auto & value{ L"Windows.Foundation.Collections.CollectionChange" };
+    };
+    template <typename K, typename V> struct name<Windows::Foundation::Collections::MapChangedEventHandler<K, V>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.MapChangedEventHandler`2<", name_v<K>, L", ", name_v<V>, L">") };
+    };
+    template <typename T> struct name<Windows::Foundation::Collections::VectorChangedEventHandler<T>>
+    {
+        static constexpr auto value{ zcombine(L"Windows.Foundation.Collections.VectorChangedEventHandler`1<", name_v<T>, L">") };
+    };
+    template <typename T> struct guid_storage<Windows::Foundation::Collections::IIterable<T>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IIterable<T>>::value };
+    };
+    template <typename T> struct guid_storage<Windows::Foundation::Collections::IIterator<T>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IIterator<T>>::value };
+    };
+    template <typename K, typename V> struct guid_storage<Windows::Foundation::Collections::IKeyValuePair<K, V>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IKeyValuePair<K, V>>::value };
+    };
+    template <typename K> struct guid_storage<Windows::Foundation::Collections::IMapChangedEventArgs<K>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IMapChangedEventArgs<K>>::value };
+    };
+    template <typename K, typename V> struct guid_storage<Windows::Foundation::Collections::IMapView<K, V>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IMapView<K, V>>::value };
+    };
+    template <typename K, typename V> struct guid_storage<Windows::Foundation::Collections::IMap<K, V>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IMap<K, V>>::value };
+    };
+    template <typename K, typename V> struct guid_storage<Windows::Foundation::Collections::IObservableMap<K, V>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IObservableMap<K, V>>::value };
+    };
+    template <typename T> struct guid_storage<Windows::Foundation::Collections::IObservableVector<T>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IObservableVector<T>>::value };
+    };
+    template <> struct guid_storage<Windows::Foundation::Collections::IPropertySet>
+    {
+        static constexpr guid value{ 0x8A43ED9F,0xF4E6,0x4421,{ 0xAC,0xF9,0x1D,0xAB,0x29,0x86,0x82,0x0C } };
+    };
+    template <> struct guid_storage<Windows::Foundation::Collections::IVectorChangedEventArgs>
+    {
+        static constexpr guid value{ 0x575933DF,0x34FE,0x4480,{ 0xAF,0x15,0x07,0x69,0x1F,0x3D,0x5D,0x9B } };
+    };
+    template <typename T> struct guid_storage<Windows::Foundation::Collections::IVectorView<T>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IVectorView<T>>::value };
+    };
+    template <typename T> struct guid_storage<Windows::Foundation::Collections::IVector<T>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::IVector<T>>::value };
+    };
+    template <typename K, typename V> struct guid_storage<Windows::Foundation::Collections::MapChangedEventHandler<K, V>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::MapChangedEventHandler<K, V>>::value };
+    };
+    template <typename T> struct guid_storage<Windows::Foundation::Collections::VectorChangedEventHandler<T>>
+    {
+        static constexpr guid value{ pinterface_guid<Windows::Foundation::Collections::VectorChangedEventHandler<T>>::value };
+    };
+    template <> struct default_interface<Windows::Foundation::Collections::PropertySet>
+    {
+        using type = Windows::Foundation::Collections::IPropertySet;
+    };
+    template <> struct default_interface<Windows::Foundation::Collections::StringMap>
+    {
+        using type = Windows::Foundation::Collections::IMap<hstring, hstring>;
+    };
+    template <> struct default_interface<Windows::Foundation::Collections::ValueSet>
+    {
+        using type = Windows::Foundation::Collections::IPropertySet;
+    };
+    template <typename T> struct abi<Windows::Foundation::Collections::IIterable<T>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall First(void**) noexcept = 0;
+        };
+    };
+    template <typename T> struct abi<Windows::Foundation::Collections::IIterator<T>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Current(arg_out<T>) noexcept = 0;
+            virtual int32_t __stdcall get_HasCurrent(bool*) noexcept = 0;
+            virtual int32_t __stdcall MoveNext(bool*) noexcept = 0;
+            virtual int32_t __stdcall GetMany(uint32_t, arg_out<T>, uint32_t*) noexcept = 0;
+        };
+    };
+    template <typename K, typename V> struct abi<Windows::Foundation::Collections::IKeyValuePair<K, V>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Key(arg_out<K>) noexcept = 0;
+            virtual int32_t __stdcall get_Value(arg_out<V>) noexcept = 0;
+        };
+    };
+    template <typename K> struct abi<Windows::Foundation::Collections::IMapChangedEventArgs<K>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_CollectionChange(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall get_Key(arg_out<K>) noexcept = 0;
+        };
+    };
+    template <typename K, typename V> struct abi<Windows::Foundation::Collections::IMapView<K, V>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall Lookup(arg_in<K>, arg_out<V>) noexcept = 0;
+            virtual int32_t __stdcall get_Size(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall HasKey(arg_in<K>, bool*) noexcept = 0;
+            virtual int32_t __stdcall Split(void**, void**) noexcept = 0;
+        };
+    };
+    template <typename K, typename V> struct abi<Windows::Foundation::Collections::IMap<K, V>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall Lookup(arg_in<K>, arg_out<V>) noexcept = 0;
+            virtual int32_t __stdcall get_Size(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall HasKey(arg_in<K>, bool*) noexcept = 0;
+            virtual int32_t __stdcall GetView(void**) noexcept = 0;
+            virtual int32_t __stdcall Insert(arg_in<K>, arg_in<V>, bool*) noexcept = 0;
+            virtual int32_t __stdcall Remove(arg_in<K>) noexcept = 0;
+            virtual int32_t __stdcall Clear() noexcept = 0;
+        };
+    };
+    template <typename K, typename V> struct abi<Windows::Foundation::Collections::IObservableMap<K, V>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall add_MapChanged(void*, winrt::event_token*) noexcept = 0;
+            virtual int32_t __stdcall remove_MapChanged(winrt::event_token) noexcept = 0;
+        };
+    };
+    template <typename T> struct abi<Windows::Foundation::Collections::IObservableVector<T>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall add_VectorChanged(void*, winrt::event_token*) noexcept = 0;
+            virtual int32_t __stdcall remove_VectorChanged(winrt::event_token) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Foundation::Collections::IPropertySet>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+        };
+    };
+    template <> struct abi<Windows::Foundation::Collections::IVectorChangedEventArgs>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_CollectionChange(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall get_Index(uint32_t*) noexcept = 0;
+        };
+    };
+    template <typename T> struct abi<Windows::Foundation::Collections::IVectorView<T>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetAt(uint32_t, arg_out<T>) noexcept = 0;
+            virtual int32_t __stdcall get_Size(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall IndexOf(arg_in<T>, uint32_t*, bool*) noexcept = 0;
+            virtual int32_t __stdcall GetMany(uint32_t, uint32_t, arg_out<T>, uint32_t*) noexcept = 0;
+        };
+    };
+    template <typename T> struct abi<Windows::Foundation::Collections::IVector<T>>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetAt(uint32_t, arg_out<T>) noexcept = 0;
+            virtual int32_t __stdcall get_Size(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall GetView(void**) noexcept = 0;
+            virtual int32_t __stdcall IndexOf(arg_in<T>, uint32_t*, bool*) noexcept = 0;
+            virtual int32_t __stdcall SetAt(uint32_t, arg_in<T>) noexcept = 0;
+            virtual int32_t __stdcall InsertAt(uint32_t, arg_in<T>) noexcept = 0;
+            virtual int32_t __stdcall RemoveAt(uint32_t) noexcept = 0;
+            virtual int32_t __stdcall Append(arg_in<T>) noexcept = 0;
+            virtual int32_t __stdcall RemoveAtEnd() noexcept = 0;
+            virtual int32_t __stdcall Clear() noexcept = 0;
+            virtual int32_t __stdcall GetMany(uint32_t, uint32_t, arg_out<T>, uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall ReplaceAll(uint32_t, arg_out<T>) noexcept = 0;
+        };
+    };
+    template <typename K, typename V> struct abi<Windows::Foundation::Collections::MapChangedEventHandler<K, V>>
+    {
+        struct __declspec(novtable) type : unknown_abi
+        {
+            virtual int32_t __stdcall Invoke(void*, void*) noexcept = 0;
+        };
+    };
+    template <typename T> struct abi<Windows::Foundation::Collections::VectorChangedEventHandler<T>>
+    {
+        struct __declspec(novtable) type : unknown_abi
+        {
+            virtual int32_t __stdcall Invoke(void*, void*) noexcept = 0;
+        };
+    };
+    template <typename D, typename T>
+    struct consume_Windows_Foundation_Collections_IIterable
+    {
+        auto First() const;
+    };
+    template <typename T> struct consume<Windows::Foundation::Collections::IIterable<T>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IIterable<D, T>;
+    };
+    template <typename D, typename T>
+    struct consume_Windows_Foundation_Collections_IIterator
+    {
+        [[nodiscard]] auto Current() const;
+        [[nodiscard]] auto HasCurrent() const;
+        auto MoveNext() const;
+        auto GetMany(array_view<T> items) const;
+
+        auto& operator++()
+        {
+            if (!MoveNext())
+            {
+                static_cast<D&>(*this) = nullptr;
+            }
+
+            return *this;
+        }
+
+        T operator*() const
+        {
+            return Current();
+        }
+    };
+    template <typename T> struct consume<Windows::Foundation::Collections::IIterator<T>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IIterator<D, T>;
+    };
+    template <typename D, typename K, typename V>
+    struct consume_Windows_Foundation_Collections_IKeyValuePair
+    {
+        [[nodiscard]] auto Key() const;
+        [[nodiscard]] auto Value() const;
+
+        bool operator==(Windows::Foundation::Collections::IKeyValuePair<K, V> const& other) const
+        {
+            return Key() == other.Key() && Value() == other.Value();
+        }
+
+        bool operator!=(Windows::Foundation::Collections::IKeyValuePair<K, V> const& other) const
+        {
+            return !(*this == other);
+        }
+    };
+    template <typename K, typename V> struct consume<Windows::Foundation::Collections::IKeyValuePair<K, V>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IKeyValuePair<D, K, V>;
+    };
+    template <typename D, typename K>
+    struct consume_Windows_Foundation_Collections_IMapChangedEventArgs
+    {
+        [[nodiscard]] auto CollectionChange() const;
+        [[nodiscard]] auto Key() const;
+    };
+    template <typename K> struct consume<Windows::Foundation::Collections::IMapChangedEventArgs<K>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IMapChangedEventArgs<D, K>;
+    };
+    template <typename D, typename K, typename V>
+    struct consume_Windows_Foundation_Collections_IMapView
+    {
+        auto Lookup(impl::param_type<K> const& key) const;
+        [[nodiscard]] auto Size() const;
+        auto HasKey(impl::param_type<K> const& key) const;
+        auto Split(Windows::Foundation::Collections::IMapView<K, V>& first, Windows::Foundation::Collections::IMapView<K, V>& second) const;
+
+        auto TryLookup(param_type<K> const& key) const noexcept
+        {
+            if constexpr (std::is_base_of_v<Windows::Foundation::IUnknown, V>)
+            {
+                V result{ nullptr };
+                WINRT_IMPL_SHIM(Windows::Foundation::Collections::IMapView<K, V>)->Lookup(get_abi(key), put_abi(result));
+                return result;
+            }
+            else
+            {
+                std::optional<V> result;
+                V value{ empty_value<V>() };
+
+                if (error_ok == WINRT_IMPL_SHIM(Windows::Foundation::Collections::IMapView<K, V>)->Lookup(get_abi(key), put_abi(value)))
+                {
+                    result = std::move(value);
+                }
+
+                return result;
+            }
+        }
+    };
+    template <typename K, typename V> struct consume<Windows::Foundation::Collections::IMapView<K, V>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IMapView<D, K, V>;
+    };
+    template <typename D, typename K, typename V>
+    struct consume_Windows_Foundation_Collections_IMap
+    {
+        auto Lookup(impl::param_type<K> const& key) const;
+        [[nodiscard]] auto Size() const;
+        auto HasKey(impl::param_type<K> const& key) const;
+        auto GetView() const;
+        auto Insert(impl::param_type<K> const& key, impl::param_type<V> const& value) const;
+        auto Remove(impl::param_type<K> const& key) const;
+        auto Clear() const;
+
+        auto TryLookup(param_type<K> const& key) const noexcept
+        {
+            if constexpr (std::is_base_of_v<Windows::Foundation::IUnknown, V>)
+            {
+                V result{ nullptr };
+                WINRT_IMPL_SHIM(Windows::Foundation::Collections::IMap<K, V>)->Lookup(get_abi(key), put_abi(result));
+                return result;
+            }
+            else
+            {
+                std::optional<V> result;
+                V value{ empty_value<V>() };
+
+                if (error_ok == WINRT_IMPL_SHIM(Windows::Foundation::Collections::IMap<K, V>)->Lookup(get_abi(key), put_abi(value)))
+                {
+                    result = std::move(value);
+                }
+
+                return result;
+            }
+        }
+    };
+    template <typename K, typename V> struct consume<Windows::Foundation::Collections::IMap<K, V>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IMap<D, K, V>;
+    };
+    template <typename D, typename K, typename V>
+    struct consume_Windows_Foundation_Collections_IObservableMap
+    {
+        auto MapChanged(Windows::Foundation::Collections::MapChangedEventHandler<K, V> const& vhnd) const;
+        using MapChanged_revoker = impl::event_revoker<Windows::Foundation::Collections::IObservableMap<K, V>, &impl::abi_t<Windows::Foundation::Collections::IObservableMap<K, V>>::remove_MapChanged>;
+        MapChanged_revoker MapChanged(auto_revoke_t, Windows::Foundation::Collections::MapChangedEventHandler<K, V> const& vhnd) const;
+        auto MapChanged(winrt::event_token const& token) const noexcept;
+    };
+    template <typename K, typename V> struct consume<Windows::Foundation::Collections::IObservableMap<K, V>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IObservableMap<D, K, V>;
+    };
+    template <typename D, typename T>
+    struct consume_Windows_Foundation_Collections_IObservableVector
+    {
+        auto VectorChanged(Windows::Foundation::Collections::VectorChangedEventHandler<T> const& vhnd) const;
+        using VectorChanged_revoker = impl::event_revoker<Windows::Foundation::Collections::IObservableVector<T>, &impl::abi_t<Windows::Foundation::Collections::IObservableVector<T>>::remove_VectorChanged>;
+        VectorChanged_revoker VectorChanged(auto_revoke_t, Windows::Foundation::Collections::VectorChangedEventHandler<T> const& vhnd) const;
+        auto VectorChanged(winrt::event_token const& token) const noexcept;
+    };
+    template <typename T> struct consume<Windows::Foundation::Collections::IObservableVector<T>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IObservableVector<D, T>;
+    };
+    template <typename D>
+    struct consume_Windows_Foundation_Collections_IPropertySet
+    {
+    };
+    template <> struct consume<Windows::Foundation::Collections::IPropertySet>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IPropertySet<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Foundation_Collections_IVectorChangedEventArgs
+    {
+        [[nodiscard]] auto CollectionChange() const;
+        [[nodiscard]] auto Index() const;
+    };
+    template <> struct consume<Windows::Foundation::Collections::IVectorChangedEventArgs>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IVectorChangedEventArgs<D>;
+    };
+    template <typename D, typename T>
+    struct consume_Windows_Foundation_Collections_IVectorView
+    {
+        auto GetAt(uint32_t index) const;
+        [[nodiscard]] auto Size() const;
+        auto IndexOf(impl::param_type<T> const& value, uint32_t& index) const;
+        auto GetMany(uint32_t startIndex, array_view<T> items) const;
+    };
+    template <typename T> struct consume<Windows::Foundation::Collections::IVectorView<T>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IVectorView<D, T>;
+    };
+    template <typename D, typename T>
+    struct consume_Windows_Foundation_Collections_IVector
+    {
+        auto GetAt(uint32_t index) const;
+        [[nodiscard]] auto Size() const;
+        auto GetView() const;
+        auto IndexOf(impl::param_type<T> const& value, uint32_t& index) const;
+        auto SetAt(uint32_t index, impl::param_type<T> const& value) const;
+        auto InsertAt(uint32_t index, impl::param_type<T> const& value) const;
+        auto RemoveAt(uint32_t index) const;
+        auto Append(impl::param_type<T> const& value) const;
+        auto RemoveAtEnd() const;
+        auto Clear() const;
+        auto GetMany(uint32_t startIndex, array_view<T> items) const;
+        auto ReplaceAll(array_view<T const> items) const;
+    };
+    template <typename T> struct consume<Windows::Foundation::Collections::IVector<T>>
+    {
+        template <typename D> using type = consume_Windows_Foundation_Collections_IVector<D, T>;
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Foundation.Collections.1.h

@@ -0,0 +1,133 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Foundation_Collections_1_H
+#define WINRT_Windows_Foundation_Collections_1_H
+#include "Windows.Foundation.Collections.0.h"
+namespace winrt::Windows::Foundation::Collections
+{
+    template <typename T>
+    struct __declspec(empty_bases) IIterable :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IIterable<T>>
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        IIterable(std::nullptr_t = nullptr) noexcept {}
+        IIterable(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename T>
+    struct __declspec(empty_bases) IIterator :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IIterator<T>>
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        IIterator(std::nullptr_t = nullptr) noexcept {}
+        IIterator(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+
+        using iterator_category = std::input_iterator_tag;
+        using value_type = T;
+        using difference_type = ptrdiff_t;
+        using pointer = T*;
+        using reference = T&;
+    };
+    template <typename K, typename V>
+    struct __declspec(empty_bases) IKeyValuePair :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IKeyValuePair<K, V>>
+    {
+        static_assert(impl::has_category_v<K>, "K must be WinRT type.");
+        static_assert(impl::has_category_v<V>, "V must be WinRT type.");
+        IKeyValuePair(std::nullptr_t = nullptr) noexcept {}
+        IKeyValuePair(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename K>
+    struct __declspec(empty_bases) IMapChangedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IMapChangedEventArgs<K>>
+    {
+        static_assert(impl::has_category_v<K>, "K must be WinRT type.");
+        IMapChangedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IMapChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename K, typename V>
+    struct __declspec(empty_bases) IMapView :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IMapView<K, V>>,
+        impl::require<Windows::Foundation::Collections::IMapView<K, V>, Windows::Foundation::Collections::IIterable<Windows::Foundation::Collections::IKeyValuePair<K, V>>>
+    {
+        static_assert(impl::has_category_v<K>, "K must be WinRT type.");
+        static_assert(impl::has_category_v<V>, "V must be WinRT type.");
+        IMapView(std::nullptr_t = nullptr) noexcept {}
+        IMapView(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename K, typename V>
+    struct __declspec(empty_bases) IMap :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IMap<K, V>>,
+        impl::require<Windows::Foundation::Collections::IMap<K, V>, Windows::Foundation::Collections::IIterable<Windows::Foundation::Collections::IKeyValuePair<K, V>>>
+    {
+        static_assert(impl::has_category_v<K>, "K must be WinRT type.");
+        static_assert(impl::has_category_v<V>, "V must be WinRT type.");
+        IMap(std::nullptr_t = nullptr) noexcept {}
+        IMap(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename K, typename V>
+    struct __declspec(empty_bases) IObservableMap :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IObservableMap<K, V>>,
+        impl::require<Windows::Foundation::Collections::IObservableMap<K, V>, Windows::Foundation::Collections::IIterable<Windows::Foundation::Collections::IKeyValuePair<K, V>>, Windows::Foundation::Collections::IMap<K, V>>
+    {
+        static_assert(impl::has_category_v<K>, "K must be WinRT type.");
+        static_assert(impl::has_category_v<V>, "V must be WinRT type.");
+        IObservableMap(std::nullptr_t = nullptr) noexcept {}
+        IObservableMap(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename T>
+    struct __declspec(empty_bases) IObservableVector :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IObservableVector<T>>,
+        impl::require<Windows::Foundation::Collections::IObservableVector<T>, Windows::Foundation::Collections::IIterable<T>, Windows::Foundation::Collections::IVector<T>>
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        IObservableVector(std::nullptr_t = nullptr) noexcept {}
+        IObservableVector(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPropertySet :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPropertySet>,
+        impl::require<Windows::Foundation::Collections::IPropertySet, Windows::Foundation::Collections::IIterable<Windows::Foundation::Collections::IKeyValuePair<hstring, Windows::Foundation::IInspectable>>, Windows::Foundation::Collections::IMap<hstring, Windows::Foundation::IInspectable>, Windows::Foundation::Collections::IObservableMap<hstring, Windows::Foundation::IInspectable>>
+    {
+        IPropertySet(std::nullptr_t = nullptr) noexcept {}
+        IPropertySet(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IVectorChangedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IVectorChangedEventArgs>
+    {
+        IVectorChangedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IVectorChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename T>
+    struct __declspec(empty_bases) IVectorView :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IVectorView<T>>,
+        impl::require<Windows::Foundation::Collections::IVectorView<T>, Windows::Foundation::Collections::IIterable<T>>
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        IVectorView(std::nullptr_t = nullptr) noexcept {}
+        IVectorView(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    template <typename T>
+    struct __declspec(empty_bases) IVector :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<Windows::Foundation::Collections::IVector<T>>,
+        impl::require<Windows::Foundation::Collections::IVector<T>, Windows::Foundation::Collections::IIterable<T>>
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        IVector(std::nullptr_t = nullptr) noexcept {}
+        IVector(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Foundation.Collections.2.h

@@ -0,0 +1,58 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Foundation_Collections_2_H
+#define WINRT_Windows_Foundation_Collections_2_H
+#include "Windows.Foundation.Collections.1.h"
+namespace winrt::Windows::Foundation::Collections
+{
+    template <typename K, typename V>
+    struct MapChangedEventHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<K>, "K must be WinRT type.");
+        static_assert(impl::has_category_v<V>, "V must be WinRT type.");
+        MapChangedEventHandler(std::nullptr_t = nullptr) noexcept {}
+        MapChangedEventHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> MapChangedEventHandler(L lambda);
+        template <typename F> MapChangedEventHandler(F* function);
+        template <typename O, typename M> MapChangedEventHandler(O* object, M method);
+        template <typename O, typename M> MapChangedEventHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> MapChangedEventHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::Collections::IObservableMap<K, V> const& sender, Windows::Foundation::Collections::IMapChangedEventArgs<K> const& event) const;
+    };
+    template <typename T>
+    struct VectorChangedEventHandler : Windows::Foundation::IUnknown
+    {
+        static_assert(impl::has_category_v<T>, "T must be WinRT type.");
+        VectorChangedEventHandler(std::nullptr_t = nullptr) noexcept {}
+        VectorChangedEventHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> VectorChangedEventHandler(L lambda);
+        template <typename F> VectorChangedEventHandler(F* function);
+        template <typename O, typename M> VectorChangedEventHandler(O* object, M method);
+        template <typename O, typename M> VectorChangedEventHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> VectorChangedEventHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Foundation::Collections::IObservableVector<T> const& sender, Windows::Foundation::Collections::IVectorChangedEventArgs const& event) const;
+    };
+    struct __declspec(empty_bases) PropertySet : Windows::Foundation::Collections::IPropertySet
+    {
+        PropertySet(std::nullptr_t) noexcept {}
+        PropertySet(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::Collections::IPropertySet(ptr, take_ownership_from_abi) {}
+        PropertySet();
+    };
+    struct __declspec(empty_bases) StringMap : Windows::Foundation::Collections::IMap<hstring, hstring>,
+        impl::require<StringMap, Windows::Foundation::Collections::IObservableMap<hstring, hstring>>
+    {
+        StringMap(std::nullptr_t) noexcept {}
+        StringMap(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::Collections::IMap<hstring, hstring>(ptr, take_ownership_from_abi) {}
+        StringMap();
+    };
+    struct __declspec(empty_bases) ValueSet : Windows::Foundation::Collections::IPropertySet
+    {
+        ValueSet(std::nullptr_t) noexcept {}
+        ValueSet(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::Collections::IPropertySet(ptr, take_ownership_from_abi) {}
+        ValueSet();
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.1.h

@@ -0,0 +1,448 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_1_H
+#define WINRT_Windows_Storage_1_H
+#include "Windows.Foundation.0.h"
+#include "Windows.Storage.Streams.0.h"
+#include "Windows.Storage.0.h"
+namespace winrt::Windows::Storage
+{
+    struct __declspec(empty_bases) IAppDataPaths :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDataPaths>
+    {
+        IAppDataPaths(std::nullptr_t = nullptr) noexcept {}
+        IAppDataPaths(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDataPathsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDataPathsStatics>
+    {
+        IAppDataPathsStatics(std::nullptr_t = nullptr) noexcept {}
+        IAppDataPathsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IApplicationData :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IApplicationData>
+    {
+        IApplicationData(std::nullptr_t = nullptr) noexcept {}
+        IApplicationData(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IApplicationData2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IApplicationData2>
+    {
+        IApplicationData2(std::nullptr_t = nullptr) noexcept {}
+        IApplicationData2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IApplicationData3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IApplicationData3>
+    {
+        IApplicationData3(std::nullptr_t = nullptr) noexcept {}
+        IApplicationData3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IApplicationDataContainer :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IApplicationDataContainer>
+    {
+        IApplicationDataContainer(std::nullptr_t = nullptr) noexcept {}
+        IApplicationDataContainer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IApplicationDataStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IApplicationDataStatics>
+    {
+        IApplicationDataStatics(std::nullptr_t = nullptr) noexcept {}
+        IApplicationDataStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IApplicationDataStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IApplicationDataStatics2>
+    {
+        IApplicationDataStatics2(std::nullptr_t = nullptr) noexcept {}
+        IApplicationDataStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ICachedFileManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ICachedFileManagerStatics>
+    {
+        ICachedFileManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        ICachedFileManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDownloadsFolderStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDownloadsFolderStatics>
+    {
+        IDownloadsFolderStatics(std::nullptr_t = nullptr) noexcept {}
+        IDownloadsFolderStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDownloadsFolderStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDownloadsFolderStatics2>
+    {
+        IDownloadsFolderStatics2(std::nullptr_t = nullptr) noexcept {}
+        IDownloadsFolderStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IFileIOStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IFileIOStatics>
+    {
+        IFileIOStatics(std::nullptr_t = nullptr) noexcept {}
+        IFileIOStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownFoldersCameraRollStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownFoldersCameraRollStatics>
+    {
+        IKnownFoldersCameraRollStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownFoldersCameraRollStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownFoldersPlaylistsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownFoldersPlaylistsStatics>
+    {
+        IKnownFoldersPlaylistsStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownFoldersPlaylistsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownFoldersSavedPicturesStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownFoldersSavedPicturesStatics>
+    {
+        IKnownFoldersSavedPicturesStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownFoldersSavedPicturesStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownFoldersStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownFoldersStatics>
+    {
+        IKnownFoldersStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownFoldersStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownFoldersStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownFoldersStatics2>
+    {
+        IKnownFoldersStatics2(std::nullptr_t = nullptr) noexcept {}
+        IKnownFoldersStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownFoldersStatics3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownFoldersStatics3>
+    {
+        IKnownFoldersStatics3(std::nullptr_t = nullptr) noexcept {}
+        IKnownFoldersStatics3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownFoldersStatics4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownFoldersStatics4>
+    {
+        IKnownFoldersStatics4(std::nullptr_t = nullptr) noexcept {}
+        IKnownFoldersStatics4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IPathIOStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IPathIOStatics>
+    {
+        IPathIOStatics(std::nullptr_t = nullptr) noexcept {}
+        IPathIOStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISetVersionDeferral :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISetVersionDeferral>
+    {
+        ISetVersionDeferral(std::nullptr_t = nullptr) noexcept {}
+        ISetVersionDeferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISetVersionRequest :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISetVersionRequest>
+    {
+        ISetVersionRequest(std::nullptr_t = nullptr) noexcept {}
+        ISetVersionRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFile :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFile>,
+        impl::require<Windows::Storage::IStorageFile, Windows::Storage::IStorageItem, Windows::Storage::Streams::IRandomAccessStreamReference, Windows::Storage::Streams::IInputStreamReference>
+    {
+        IStorageFile(std::nullptr_t = nullptr) noexcept {}
+        IStorageFile(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFile2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFile2>
+    {
+        IStorageFile2(std::nullptr_t = nullptr) noexcept {}
+        IStorageFile2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFilePropertiesWithAvailability :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFilePropertiesWithAvailability>
+    {
+        IStorageFilePropertiesWithAvailability(std::nullptr_t = nullptr) noexcept {}
+        IStorageFilePropertiesWithAvailability(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFileStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFileStatics>
+    {
+        IStorageFileStatics(std::nullptr_t = nullptr) noexcept {}
+        IStorageFileStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFileStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFileStatics2>
+    {
+        IStorageFileStatics2(std::nullptr_t = nullptr) noexcept {}
+        IStorageFileStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFolder :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFolder>,
+        impl::require<Windows::Storage::IStorageFolder, Windows::Storage::IStorageItem>
+    {
+        IStorageFolder(std::nullptr_t = nullptr) noexcept {}
+        IStorageFolder(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFolder2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFolder2>
+    {
+        IStorageFolder2(std::nullptr_t = nullptr) noexcept {}
+        IStorageFolder2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFolder3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFolder3>
+    {
+        IStorageFolder3(std::nullptr_t = nullptr) noexcept {}
+        IStorageFolder3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFolderStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFolderStatics>
+    {
+        IStorageFolderStatics(std::nullptr_t = nullptr) noexcept {}
+        IStorageFolderStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFolderStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFolderStatics2>
+    {
+        IStorageFolderStatics2(std::nullptr_t = nullptr) noexcept {}
+        IStorageFolderStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageItem :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageItem>
+    {
+        IStorageItem(std::nullptr_t = nullptr) noexcept {}
+        IStorageItem(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageItem2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageItem2>,
+        impl::require<Windows::Storage::IStorageItem2, Windows::Storage::IStorageItem>
+    {
+        IStorageItem2(std::nullptr_t = nullptr) noexcept {}
+        IStorageItem2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageItemProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageItemProperties>
+    {
+        IStorageItemProperties(std::nullptr_t = nullptr) noexcept {}
+        IStorageItemProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageItemProperties2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageItemProperties2>,
+        impl::require<Windows::Storage::IStorageItemProperties2, Windows::Storage::IStorageItemProperties>
+    {
+        IStorageItemProperties2(std::nullptr_t = nullptr) noexcept {}
+        IStorageItemProperties2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageItemPropertiesWithProvider :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageItemPropertiesWithProvider>,
+        impl::require<Windows::Storage::IStorageItemPropertiesWithProvider, Windows::Storage::IStorageItemProperties>
+    {
+        IStorageItemPropertiesWithProvider(std::nullptr_t = nullptr) noexcept {}
+        IStorageItemPropertiesWithProvider(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibrary :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibrary>
+    {
+        IStorageLibrary(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibrary(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibrary2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibrary2>
+    {
+        IStorageLibrary2(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibrary2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibrary3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibrary3>
+    {
+        IStorageLibrary3(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibrary3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibraryChange :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibraryChange>
+    {
+        IStorageLibraryChange(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibraryChange(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibraryChangeReader :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibraryChangeReader>
+    {
+        IStorageLibraryChangeReader(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibraryChangeReader(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibraryChangeTracker :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibraryChangeTracker>
+    {
+        IStorageLibraryChangeTracker(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibraryChangeTracker(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibraryStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibraryStatics>
+    {
+        IStorageLibraryStatics(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibraryStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibraryStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibraryStatics2>
+    {
+        IStorageLibraryStatics2(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibraryStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageProvider :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageProvider>
+    {
+        IStorageProvider(std::nullptr_t = nullptr) noexcept {}
+        IStorageProvider(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageProvider2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageProvider2>,
+        impl::require<Windows::Storage::IStorageProvider2, Windows::Storage::IStorageProvider>
+    {
+        IStorageProvider2(std::nullptr_t = nullptr) noexcept {}
+        IStorageProvider2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageStreamTransaction :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageStreamTransaction>,
+        impl::require<Windows::Storage::IStorageStreamTransaction, Windows::Foundation::IClosable>
+    {
+        IStorageStreamTransaction(std::nullptr_t = nullptr) noexcept {}
+        IStorageStreamTransaction(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStreamedFileDataRequest :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStreamedFileDataRequest>
+    {
+        IStreamedFileDataRequest(std::nullptr_t = nullptr) noexcept {}
+        IStreamedFileDataRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemAudioProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemAudioProperties>
+    {
+        ISystemAudioProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemAudioProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemDataPaths :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemDataPaths>
+    {
+        ISystemDataPaths(std::nullptr_t = nullptr) noexcept {}
+        ISystemDataPaths(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemDataPathsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemDataPathsStatics>
+    {
+        ISystemDataPathsStatics(std::nullptr_t = nullptr) noexcept {}
+        ISystemDataPathsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemGPSProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemGPSProperties>
+    {
+        ISystemGPSProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemGPSProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemImageProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemImageProperties>
+    {
+        ISystemImageProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemImageProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemMediaProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemMediaProperties>
+    {
+        ISystemMediaProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemMediaProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemMusicProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemMusicProperties>
+    {
+        ISystemMusicProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemMusicProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemPhotoProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemPhotoProperties>
+    {
+        ISystemPhotoProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemPhotoProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemProperties>
+    {
+        ISystemProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ISystemVideoProperties :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ISystemVideoProperties>
+    {
+        ISystemVideoProperties(std::nullptr_t = nullptr) noexcept {}
+        ISystemVideoProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserDataPaths :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserDataPaths>
+    {
+        IUserDataPaths(std::nullptr_t = nullptr) noexcept {}
+        IUserDataPaths(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserDataPathsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserDataPathsStatics>
+    {
+        IUserDataPathsStatics(std::nullptr_t = nullptr) noexcept {}
+        IUserDataPathsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.2.h

@@ -0,0 +1,293 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_2_H
+#define WINRT_Windows_Storage_2_H
+#include "Windows.Foundation.1.h"
+#include "Windows.Foundation.Collections.1.h"
+#include "Windows.Storage.Search.1.h"
+#include "Windows.Storage.Streams.1.h"
+#include "Windows.System.1.h"
+#include "Windows.Storage.1.h"
+namespace winrt::Windows::Storage
+{
+    struct ApplicationDataSetVersionHandler : Windows::Foundation::IUnknown
+    {
+        ApplicationDataSetVersionHandler(std::nullptr_t = nullptr) noexcept {}
+        ApplicationDataSetVersionHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> ApplicationDataSetVersionHandler(L lambda);
+        template <typename F> ApplicationDataSetVersionHandler(F* function);
+        template <typename O, typename M> ApplicationDataSetVersionHandler(O* object, M method);
+        template <typename O, typename M> ApplicationDataSetVersionHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> ApplicationDataSetVersionHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Storage::SetVersionRequest const& setVersionRequest) const;
+    };
+    struct StreamedFileDataRequestedHandler : Windows::Foundation::IUnknown
+    {
+        StreamedFileDataRequestedHandler(std::nullptr_t = nullptr) noexcept {}
+        StreamedFileDataRequestedHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> StreamedFileDataRequestedHandler(L lambda);
+        template <typename F> StreamedFileDataRequestedHandler(F* function);
+        template <typename O, typename M> StreamedFileDataRequestedHandler(O* object, M method);
+        template <typename O, typename M> StreamedFileDataRequestedHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> StreamedFileDataRequestedHandler(weak_ref<O>&& object, M method);
+        auto operator()(Windows::Storage::StreamedFileDataRequest const& stream) const;
+    };
+    struct __declspec(empty_bases) AppDataPaths : Windows::Storage::IAppDataPaths
+    {
+        AppDataPaths(std::nullptr_t) noexcept {}
+        AppDataPaths(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IAppDataPaths(ptr, take_ownership_from_abi) {}
+        static auto GetForUser(Windows::System::User const& user);
+        static auto GetDefault();
+    };
+    struct __declspec(empty_bases) ApplicationData : Windows::Storage::IApplicationData,
+        impl::require<ApplicationData, Windows::Storage::IApplicationData2, Windows::Storage::IApplicationData3>
+    {
+        ApplicationData(std::nullptr_t) noexcept {}
+        ApplicationData(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IApplicationData(ptr, take_ownership_from_abi) {}
+        [[nodiscard]] static auto Current();
+        static auto GetForUserAsync(Windows::System::User const& user);
+    };
+    struct __declspec(empty_bases) ApplicationDataCompositeValue : Windows::Foundation::Collections::IPropertySet
+    {
+        ApplicationDataCompositeValue(std::nullptr_t) noexcept {}
+        ApplicationDataCompositeValue(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::Collections::IPropertySet(ptr, take_ownership_from_abi) {}
+        ApplicationDataCompositeValue();
+    };
+    struct __declspec(empty_bases) ApplicationDataContainer : Windows::Storage::IApplicationDataContainer
+    {
+        ApplicationDataContainer(std::nullptr_t) noexcept {}
+        ApplicationDataContainer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IApplicationDataContainer(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ApplicationDataContainerSettings : Windows::Foundation::Collections::IPropertySet
+    {
+        ApplicationDataContainerSettings(std::nullptr_t) noexcept {}
+        ApplicationDataContainerSettings(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::Collections::IPropertySet(ptr, take_ownership_from_abi) {}
+    };
+    struct CachedFileManager
+    {
+        CachedFileManager() = delete;
+        static auto DeferUpdates(Windows::Storage::IStorageFile const& file);
+        static auto CompleteUpdatesAsync(Windows::Storage::IStorageFile const& file);
+    };
+    struct DownloadsFolder
+    {
+        DownloadsFolder() = delete;
+        static auto CreateFileAsync(param::hstring const& desiredName);
+        static auto CreateFolderAsync(param::hstring const& desiredName);
+        static auto CreateFileAsync(param::hstring const& desiredName, Windows::Storage::CreationCollisionOption const& option);
+        static auto CreateFolderAsync(param::hstring const& desiredName, Windows::Storage::CreationCollisionOption const& option);
+        static auto CreateFileForUserAsync(Windows::System::User const& user, param::hstring const& desiredName);
+        static auto CreateFolderForUserAsync(Windows::System::User const& user, param::hstring const& desiredName);
+        static auto CreateFileForUserAsync(Windows::System::User const& user, param::hstring const& desiredName, Windows::Storage::CreationCollisionOption const& option);
+        static auto CreateFolderForUserAsync(Windows::System::User const& user, param::hstring const& desiredName, Windows::Storage::CreationCollisionOption const& option);
+    };
+    struct FileIO
+    {
+        FileIO() = delete;
+        static auto ReadTextAsync(Windows::Storage::IStorageFile const& file);
+        static auto ReadTextAsync(Windows::Storage::IStorageFile const& file, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto WriteTextAsync(Windows::Storage::IStorageFile const& file, param::hstring const& contents);
+        static auto WriteTextAsync(Windows::Storage::IStorageFile const& file, param::hstring const& contents, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto AppendTextAsync(Windows::Storage::IStorageFile const& file, param::hstring const& contents);
+        static auto AppendTextAsync(Windows::Storage::IStorageFile const& file, param::hstring const& contents, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto ReadLinesAsync(Windows::Storage::IStorageFile const& file);
+        static auto ReadLinesAsync(Windows::Storage::IStorageFile const& file, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto WriteLinesAsync(Windows::Storage::IStorageFile const& file, param::async_iterable<hstring> const& lines);
+        static auto WriteLinesAsync(Windows::Storage::IStorageFile const& file, param::async_iterable<hstring> const& lines, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto AppendLinesAsync(Windows::Storage::IStorageFile const& file, param::async_iterable<hstring> const& lines);
+        static auto AppendLinesAsync(Windows::Storage::IStorageFile const& file, param::async_iterable<hstring> const& lines, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto ReadBufferAsync(Windows::Storage::IStorageFile const& file);
+        static auto WriteBufferAsync(Windows::Storage::IStorageFile const& file, Windows::Storage::Streams::IBuffer const& buffer);
+        static auto WriteBytesAsync(Windows::Storage::IStorageFile const& file, array_view<uint8_t const> buffer);
+    };
+    struct KnownFolders
+    {
+        KnownFolders() = delete;
+        [[nodiscard]] static auto CameraRoll();
+        [[nodiscard]] static auto Playlists();
+        [[nodiscard]] static auto SavedPictures();
+        [[nodiscard]] static auto MusicLibrary();
+        [[nodiscard]] static auto PicturesLibrary();
+        [[nodiscard]] static auto VideosLibrary();
+        [[nodiscard]] static auto DocumentsLibrary();
+        [[nodiscard]] static auto HomeGroup();
+        [[nodiscard]] static auto RemovableDevices();
+        [[nodiscard]] static auto MediaServerDevices();
+        [[nodiscard]] static auto Objects3D();
+        [[nodiscard]] static auto AppCaptures();
+        [[nodiscard]] static auto RecordedCalls();
+        static auto GetFolderForUserAsync(Windows::System::User const& user, Windows::Storage::KnownFolderId const& folderId);
+        static auto RequestAccessAsync(Windows::Storage::KnownFolderId const& folderId);
+        static auto RequestAccessForUserAsync(Windows::System::User const& user, Windows::Storage::KnownFolderId const& folderId);
+        static auto GetFolderAsync(Windows::Storage::KnownFolderId const& folderId);
+    };
+    struct PathIO
+    {
+        PathIO() = delete;
+        static auto ReadTextAsync(param::hstring const& absolutePath);
+        static auto ReadTextAsync(param::hstring const& absolutePath, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto WriteTextAsync(param::hstring const& absolutePath, param::hstring const& contents);
+        static auto WriteTextAsync(param::hstring const& absolutePath, param::hstring const& contents, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto AppendTextAsync(param::hstring const& absolutePath, param::hstring const& contents);
+        static auto AppendTextAsync(param::hstring const& absolutePath, param::hstring const& contents, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto ReadLinesAsync(param::hstring const& absolutePath);
+        static auto ReadLinesAsync(param::hstring const& absolutePath, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto WriteLinesAsync(param::hstring const& absolutePath, param::async_iterable<hstring> const& lines);
+        static auto WriteLinesAsync(param::hstring const& absolutePath, param::async_iterable<hstring> const& lines, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto AppendLinesAsync(param::hstring const& absolutePath, param::async_iterable<hstring> const& lines);
+        static auto AppendLinesAsync(param::hstring const& absolutePath, param::async_iterable<hstring> const& lines, Windows::Storage::Streams::UnicodeEncoding const& encoding);
+        static auto ReadBufferAsync(param::hstring const& absolutePath);
+        static auto WriteBufferAsync(param::hstring const& absolutePath, Windows::Storage::Streams::IBuffer const& buffer);
+        static auto WriteBytesAsync(param::hstring const& absolutePath, array_view<uint8_t const> buffer);
+    };
+    struct __declspec(empty_bases) SetVersionDeferral : Windows::Storage::ISetVersionDeferral
+    {
+        SetVersionDeferral(std::nullptr_t) noexcept {}
+        SetVersionDeferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISetVersionDeferral(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SetVersionRequest : Windows::Storage::ISetVersionRequest
+    {
+        SetVersionRequest(std::nullptr_t) noexcept {}
+        SetVersionRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISetVersionRequest(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageFile : Windows::Storage::IStorageFile,
+        impl::require<StorageFile, Windows::Storage::IStorageItemProperties, Windows::Storage::IStorageItemProperties2, Windows::Storage::IStorageItem2, Windows::Storage::IStorageItemPropertiesWithProvider, Windows::Storage::IStorageFilePropertiesWithAvailability, Windows::Storage::IStorageFile2>
+    {
+        StorageFile(std::nullptr_t) noexcept {}
+        StorageFile(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageFile(ptr, take_ownership_from_abi) {}
+        using Windows::Storage::IStorageFile::OpenAsync;
+        using impl::consume_t<StorageFile, Windows::Storage::IStorageFile2>::OpenAsync;
+        using Windows::Storage::IStorageFile::OpenTransactedWriteAsync;
+        using impl::consume_t<StorageFile, Windows::Storage::IStorageFile2>::OpenTransactedWriteAsync;
+        static auto GetFileFromPathAsync(param::hstring const& path);
+        static auto GetFileFromApplicationUriAsync(Windows::Foundation::Uri const& uri);
+        static auto CreateStreamedFileAsync(param::hstring const& displayNameWithExtension, Windows::Storage::StreamedFileDataRequestedHandler const& dataRequested, Windows::Storage::Streams::IRandomAccessStreamReference const& thumbnail);
+        static auto ReplaceWithStreamedFileAsync(Windows::Storage::IStorageFile const& fileToReplace, Windows::Storage::StreamedFileDataRequestedHandler const& dataRequested, Windows::Storage::Streams::IRandomAccessStreamReference const& thumbnail);
+        static auto CreateStreamedFileFromUriAsync(param::hstring const& displayNameWithExtension, Windows::Foundation::Uri const& uri, Windows::Storage::Streams::IRandomAccessStreamReference const& thumbnail);
+        static auto ReplaceWithStreamedFileFromUriAsync(Windows::Storage::IStorageFile const& fileToReplace, Windows::Foundation::Uri const& uri, Windows::Storage::Streams::IRandomAccessStreamReference const& thumbnail);
+        static auto GetFileFromPathForUserAsync(Windows::System::User const& user, param::hstring const& path);
+    };
+    struct __declspec(empty_bases) StorageFolder : Windows::Storage::IStorageFolder,
+        impl::require<StorageFolder, Windows::Storage::Search::IStorageFolderQueryOperations, Windows::Storage::IStorageItemProperties, Windows::Storage::IStorageItemProperties2, Windows::Storage::IStorageItem2, Windows::Storage::IStorageFolder2, Windows::Storage::IStorageItemPropertiesWithProvider, Windows::Storage::IStorageFolder3>
+    {
+        StorageFolder(std::nullptr_t) noexcept {}
+        StorageFolder(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageFolder(ptr, take_ownership_from_abi) {}
+        using Windows::Storage::IStorageFolder::GetFilesAsync;
+        using impl::consume_t<StorageFolder, Windows::Storage::Search::IStorageFolderQueryOperations>::GetFilesAsync;
+        using Windows::Storage::IStorageFolder::GetFoldersAsync;
+        using impl::consume_t<StorageFolder, Windows::Storage::Search::IStorageFolderQueryOperations>::GetFoldersAsync;
+        using Windows::Storage::IStorageFolder::GetItemsAsync;
+        using impl::consume_t<StorageFolder, Windows::Storage::Search::IStorageFolderQueryOperations>::GetItemsAsync;
+        static auto GetFolderFromPathAsync(param::hstring const& path);
+        static auto GetFolderFromPathForUserAsync(Windows::System::User const& user, param::hstring const& path);
+    };
+    struct __declspec(empty_bases) StorageLibrary : Windows::Storage::IStorageLibrary,
+        impl::require<StorageLibrary, Windows::Storage::IStorageLibrary2, Windows::Storage::IStorageLibrary3>
+    {
+        StorageLibrary(std::nullptr_t) noexcept {}
+        StorageLibrary(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageLibrary(ptr, take_ownership_from_abi) {}
+        static auto GetLibraryAsync(Windows::Storage::KnownLibraryId const& libraryId);
+        static auto GetLibraryForUserAsync(Windows::System::User const& user, Windows::Storage::KnownLibraryId const& libraryId);
+    };
+    struct __declspec(empty_bases) StorageLibraryChange : Windows::Storage::IStorageLibraryChange
+    {
+        StorageLibraryChange(std::nullptr_t) noexcept {}
+        StorageLibraryChange(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageLibraryChange(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageLibraryChangeReader : Windows::Storage::IStorageLibraryChangeReader
+    {
+        StorageLibraryChangeReader(std::nullptr_t) noexcept {}
+        StorageLibraryChangeReader(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageLibraryChangeReader(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageLibraryChangeTracker : Windows::Storage::IStorageLibraryChangeTracker
+    {
+        StorageLibraryChangeTracker(std::nullptr_t) noexcept {}
+        StorageLibraryChangeTracker(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageLibraryChangeTracker(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageProvider : Windows::Storage::IStorageProvider,
+        impl::require<StorageProvider, Windows::Storage::IStorageProvider2>
+    {
+        StorageProvider(std::nullptr_t) noexcept {}
+        StorageProvider(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageProvider(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageStreamTransaction : Windows::Storage::IStorageStreamTransaction
+    {
+        StorageStreamTransaction(std::nullptr_t) noexcept {}
+        StorageStreamTransaction(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IStorageStreamTransaction(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StreamedFileDataRequest : Windows::Storage::Streams::IOutputStream,
+        impl::require<StreamedFileDataRequest, Windows::Storage::IStreamedFileDataRequest>
+    {
+        StreamedFileDataRequest(std::nullptr_t) noexcept {}
+        StreamedFileDataRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IOutputStream(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SystemAudioProperties : Windows::Storage::ISystemAudioProperties
+    {
+        SystemAudioProperties(std::nullptr_t) noexcept {}
+        SystemAudioProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemAudioProperties(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SystemDataPaths : Windows::Storage::ISystemDataPaths
+    {
+        SystemDataPaths(std::nullptr_t) noexcept {}
+        SystemDataPaths(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemDataPaths(ptr, take_ownership_from_abi) {}
+        static auto GetDefault();
+    };
+    struct __declspec(empty_bases) SystemGPSProperties : Windows::Storage::ISystemGPSProperties
+    {
+        SystemGPSProperties(std::nullptr_t) noexcept {}
+        SystemGPSProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemGPSProperties(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SystemImageProperties : Windows::Storage::ISystemImageProperties
+    {
+        SystemImageProperties(std::nullptr_t) noexcept {}
+        SystemImageProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemImageProperties(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SystemMediaProperties : Windows::Storage::ISystemMediaProperties
+    {
+        SystemMediaProperties(std::nullptr_t) noexcept {}
+        SystemMediaProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemMediaProperties(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SystemMusicProperties : Windows::Storage::ISystemMusicProperties
+    {
+        SystemMusicProperties(std::nullptr_t) noexcept {}
+        SystemMusicProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemMusicProperties(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) SystemPhotoProperties : Windows::Storage::ISystemPhotoProperties
+    {
+        SystemPhotoProperties(std::nullptr_t) noexcept {}
+        SystemPhotoProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemPhotoProperties(ptr, take_ownership_from_abi) {}
+    };
+    struct SystemProperties
+    {
+        SystemProperties() = delete;
+        [[nodiscard]] static auto Author();
+        [[nodiscard]] static auto Comment();
+        [[nodiscard]] static auto ItemNameDisplay();
+        [[nodiscard]] static auto Keywords();
+        [[nodiscard]] static auto Rating();
+        [[nodiscard]] static auto Title();
+        [[nodiscard]] static auto Audio();
+        [[nodiscard]] static auto GPS();
+        [[nodiscard]] static auto Media();
+        [[nodiscard]] static auto Music();
+        [[nodiscard]] static auto Photo();
+        [[nodiscard]] static auto Video();
+        [[nodiscard]] static auto Image();
+    };
+    struct __declspec(empty_bases) SystemVideoProperties : Windows::Storage::ISystemVideoProperties
+    {
+        SystemVideoProperties(std::nullptr_t) noexcept {}
+        SystemVideoProperties(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::ISystemVideoProperties(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) UserDataPaths : Windows::Storage::IUserDataPaths
+    {
+        UserDataPaths(std::nullptr_t) noexcept {}
+        UserDataPaths(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::IUserDataPaths(ptr, take_ownership_from_abi) {}
+        static auto GetForUser(Windows::System::User const& user);
+        static auto GetDefault();
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.Search.0.h

@@ -0,0 +1,937 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_Search_0_H
+#define WINRT_Windows_Storage_Search_0_H
+namespace winrt::Windows::Foundation
+{
+    struct EventRegistrationToken;
+    struct IAsyncAction;
+    template <typename TSender, typename TResult> struct TypedEventHandler;
+}
+namespace winrt::Windows::Foundation::Collections
+{
+    template <typename T> struct IIterable;
+    template <typename T> struct IVector;
+}
+namespace winrt::Windows::Storage
+{
+    struct StorageFile;
+    struct StorageFolder;
+    struct StorageLibraryChangeTracker;
+}
+namespace winrt::Windows::Storage::FileProperties
+{
+    enum class PropertyPrefetchOptions : uint32_t;
+    enum class ThumbnailMode : int32_t;
+    enum class ThumbnailOptions : uint32_t;
+}
+namespace winrt::Windows::Storage::Streams
+{
+    struct IRandomAccessStream;
+}
+namespace winrt::Windows::Storage::Search
+{
+    enum class CommonFileQuery : int32_t
+    {
+        DefaultQuery = 0,
+        OrderByName = 1,
+        OrderByTitle = 2,
+        OrderByMusicProperties = 3,
+        OrderBySearchRank = 4,
+        OrderByDate = 5,
+    };
+    enum class CommonFolderQuery : int32_t
+    {
+        DefaultQuery = 0,
+        GroupByYear = 100,
+        GroupByMonth = 101,
+        GroupByArtist = 102,
+        GroupByAlbum = 103,
+        GroupByAlbumArtist = 104,
+        GroupByComposer = 105,
+        GroupByGenre = 106,
+        GroupByPublishedYear = 107,
+        GroupByRating = 108,
+        GroupByTag = 109,
+        GroupByAuthor = 110,
+        GroupByType = 111,
+    };
+    enum class DateStackOption : int32_t
+    {
+        None = 0,
+        Year = 1,
+        Month = 2,
+    };
+    enum class FolderDepth : int32_t
+    {
+        Shallow = 0,
+        Deep = 1,
+    };
+    enum class IndexedState : int32_t
+    {
+        Unknown = 0,
+        NotIndexed = 1,
+        PartiallyIndexed = 2,
+        FullyIndexed = 3,
+    };
+    enum class IndexerOption : int32_t
+    {
+        UseIndexerWhenAvailable = 0,
+        OnlyUseIndexer = 1,
+        DoNotUseIndexer = 2,
+        OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
+    };
+    struct IContentIndexer;
+    struct IContentIndexerQuery;
+    struct IContentIndexerQueryOperations;
+    struct IContentIndexerStatics;
+    struct IIndexableContent;
+    struct IQueryOptions;
+    struct IQueryOptionsFactory;
+    struct IQueryOptionsWithProviderFilter;
+    struct IStorageFileQueryResult;
+    struct IStorageFileQueryResult2;
+    struct IStorageFolderQueryOperations;
+    struct IStorageFolderQueryResult;
+    struct IStorageItemQueryResult;
+    struct IStorageLibraryChangeTrackerTriggerDetails;
+    struct IStorageLibraryContentChangedTriggerDetails;
+    struct IStorageQueryResultBase;
+    struct IValueAndLanguage;
+    struct ContentIndexer;
+    struct ContentIndexerQuery;
+    struct IndexableContent;
+    struct QueryOptions;
+    struct SortEntryVector;
+    struct StorageFileQueryResult;
+    struct StorageFolderQueryResult;
+    struct StorageItemQueryResult;
+    struct StorageLibraryChangeTrackerTriggerDetails;
+    struct StorageLibraryContentChangedTriggerDetails;
+    struct ValueAndLanguage;
+    struct SortEntry;
+}
+namespace winrt::impl
+{
+    template <> struct category<Windows::Storage::Search::IContentIndexer>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IContentIndexerQuery>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IContentIndexerQueryOperations>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IContentIndexerStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IIndexableContent>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IQueryOptions>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IQueryOptionsFactory>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IQueryOptionsWithProviderFilter>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageFileQueryResult>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageFileQueryResult2>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageFolderQueryOperations>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageFolderQueryResult>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageItemQueryResult>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::IValueAndLanguage>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Search::ContentIndexer>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::ContentIndexerQuery>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::IndexableContent>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::QueryOptions>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::SortEntryVector>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::StorageFileQueryResult>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::StorageFolderQueryResult>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::StorageItemQueryResult>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::StorageLibraryChangeTrackerTriggerDetails>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::StorageLibraryContentChangedTriggerDetails>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::ValueAndLanguage>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Search::CommonFileQuery>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Search::CommonFolderQuery>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Search::DateStackOption>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Search::FolderDepth>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Search::IndexedState>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Search::IndexerOption>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Search::SortEntry>
+    {
+        using type = struct_category<hstring, bool>;
+    };
+    template <> struct name<Windows::Storage::Search::IContentIndexer>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IContentIndexer" };
+    };
+    template <> struct name<Windows::Storage::Search::IContentIndexerQuery>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IContentIndexerQuery" };
+    };
+    template <> struct name<Windows::Storage::Search::IContentIndexerQueryOperations>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IContentIndexerQueryOperations" };
+    };
+    template <> struct name<Windows::Storage::Search::IContentIndexerStatics>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IContentIndexerStatics" };
+    };
+    template <> struct name<Windows::Storage::Search::IIndexableContent>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IIndexableContent" };
+    };
+    template <> struct name<Windows::Storage::Search::IQueryOptions>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IQueryOptions" };
+    };
+    template <> struct name<Windows::Storage::Search::IQueryOptionsFactory>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IQueryOptionsFactory" };
+    };
+    template <> struct name<Windows::Storage::Search::IQueryOptionsWithProviderFilter>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IQueryOptionsWithProviderFilter" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageFileQueryResult>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageFileQueryResult" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageFileQueryResult2>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageFileQueryResult2" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageFolderQueryOperations>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageFolderQueryOperations" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageFolderQueryResult>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageFolderQueryResult" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageItemQueryResult>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageItemQueryResult" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageLibraryChangeTrackerTriggerDetails" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageLibraryContentChangedTriggerDetails" };
+    };
+    template <> struct name<Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IStorageQueryResultBase" };
+    };
+    template <> struct name<Windows::Storage::Search::IValueAndLanguage>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IValueAndLanguage" };
+    };
+    template <> struct name<Windows::Storage::Search::ContentIndexer>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.ContentIndexer" };
+    };
+    template <> struct name<Windows::Storage::Search::ContentIndexerQuery>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.ContentIndexerQuery" };
+    };
+    template <> struct name<Windows::Storage::Search::IndexableContent>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IndexableContent" };
+    };
+    template <> struct name<Windows::Storage::Search::QueryOptions>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.QueryOptions" };
+    };
+    template <> struct name<Windows::Storage::Search::SortEntryVector>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.SortEntryVector" };
+    };
+    template <> struct name<Windows::Storage::Search::StorageFileQueryResult>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.StorageFileQueryResult" };
+    };
+    template <> struct name<Windows::Storage::Search::StorageFolderQueryResult>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.StorageFolderQueryResult" };
+    };
+    template <> struct name<Windows::Storage::Search::StorageItemQueryResult>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.StorageItemQueryResult" };
+    };
+    template <> struct name<Windows::Storage::Search::StorageLibraryChangeTrackerTriggerDetails>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.StorageLibraryChangeTrackerTriggerDetails" };
+    };
+    template <> struct name<Windows::Storage::Search::StorageLibraryContentChangedTriggerDetails>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.StorageLibraryContentChangedTriggerDetails" };
+    };
+    template <> struct name<Windows::Storage::Search::ValueAndLanguage>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.ValueAndLanguage" };
+    };
+    template <> struct name<Windows::Storage::Search::CommonFileQuery>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.CommonFileQuery" };
+    };
+    template <> struct name<Windows::Storage::Search::CommonFolderQuery>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.CommonFolderQuery" };
+    };
+    template <> struct name<Windows::Storage::Search::DateStackOption>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.DateStackOption" };
+    };
+    template <> struct name<Windows::Storage::Search::FolderDepth>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.FolderDepth" };
+    };
+    template <> struct name<Windows::Storage::Search::IndexedState>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IndexedState" };
+    };
+    template <> struct name<Windows::Storage::Search::IndexerOption>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.IndexerOption" };
+    };
+    template <> struct name<Windows::Storage::Search::SortEntry>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Search.SortEntry" };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IContentIndexer>
+    {
+        static constexpr guid value{ 0xB1767F8D,0xF698,0x4982,{ 0xB0,0x5F,0x3A,0x6E,0x8C,0xAB,0x01,0xA2 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IContentIndexerQuery>
+    {
+        static constexpr guid value{ 0x70E3B0F8,0x4BFC,0x428A,{ 0x88,0x89,0xCC,0x51,0xDA,0x9A,0x7B,0x9D } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IContentIndexerQueryOperations>
+    {
+        static constexpr guid value{ 0x28823E10,0x4786,0x42F1,{ 0x97,0x30,0x79,0x2B,0x35,0x66,0xB1,0x50 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IContentIndexerStatics>
+    {
+        static constexpr guid value{ 0x8C488375,0xB37E,0x4C60,{ 0x9B,0xA8,0xB7,0x60,0xFD,0xA3,0xE5,0x9D } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IIndexableContent>
+    {
+        static constexpr guid value{ 0xCCF1A05F,0xD4B5,0x483A,{ 0xB0,0x6E,0xE0,0xDB,0x1E,0xC4,0x20,0xE4 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IQueryOptions>
+    {
+        static constexpr guid value{ 0x1E5E46EE,0x0F45,0x4838,{ 0xA8,0xE9,0xD0,0x47,0x9D,0x44,0x6C,0x30 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IQueryOptionsFactory>
+    {
+        static constexpr guid value{ 0x032E1F8C,0xA9C1,0x4E71,{ 0x80,0x11,0x0D,0xEE,0x9D,0x48,0x11,0xA3 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IQueryOptionsWithProviderFilter>
+    {
+        static constexpr guid value{ 0x5B9D1026,0x15C4,0x44DD,{ 0xB8,0x9A,0x47,0xA5,0x9B,0x7D,0x7C,0x4F } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageFileQueryResult>
+    {
+        static constexpr guid value{ 0x52FDA447,0x2BAA,0x412C,{ 0xB2,0x9F,0xD4,0xB1,0x77,0x8E,0xFA,0x1E } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageFileQueryResult2>
+    {
+        static constexpr guid value{ 0x4E5DB9DD,0x7141,0x46C4,{ 0x8B,0xE3,0xE9,0xDC,0x9E,0x27,0x27,0x5C } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageFolderQueryOperations>
+    {
+        static constexpr guid value{ 0xCB43CCC9,0x446B,0x4A4F,{ 0xBE,0x97,0x75,0x77,0x71,0xBE,0x52,0x03 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageFolderQueryResult>
+    {
+        static constexpr guid value{ 0x6654C911,0x7D66,0x46FA,{ 0xAE,0xCF,0xE4,0xA4,0xBA,0xA9,0x3A,0xB8 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageItemQueryResult>
+    {
+        static constexpr guid value{ 0xE8948079,0x9D58,0x47B8,{ 0xB2,0xB2,0x41,0xB0,0x7F,0x47,0x95,0xF9 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails>
+    {
+        static constexpr guid value{ 0x1DC7A369,0xB7A3,0x4DF2,{ 0x9D,0x61,0xEB,0xA8,0x5A,0x03,0x43,0xD2 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails>
+    {
+        static constexpr guid value{ 0x2A371977,0xABBF,0x4E1D,{ 0x8A,0xA5,0x63,0x85,0xD8,0x88,0x47,0x99 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        static constexpr guid value{ 0xC297D70D,0x7353,0x47AB,{ 0xBA,0x58,0x8C,0x61,0x42,0x5D,0xC5,0x4B } };
+    };
+    template <> struct guid_storage<Windows::Storage::Search::IValueAndLanguage>
+    {
+        static constexpr guid value{ 0xB9914881,0xA1EE,0x4BC4,{ 0x92,0xA5,0x46,0x69,0x68,0xE3,0x04,0x36 } };
+    };
+    template <> struct default_interface<Windows::Storage::Search::ContentIndexer>
+    {
+        using type = Windows::Storage::Search::IContentIndexer;
+    };
+    template <> struct default_interface<Windows::Storage::Search::ContentIndexerQuery>
+    {
+        using type = Windows::Storage::Search::IContentIndexerQuery;
+    };
+    template <> struct default_interface<Windows::Storage::Search::IndexableContent>
+    {
+        using type = Windows::Storage::Search::IIndexableContent;
+    };
+    template <> struct default_interface<Windows::Storage::Search::QueryOptions>
+    {
+        using type = Windows::Storage::Search::IQueryOptions;
+    };
+    template <> struct default_interface<Windows::Storage::Search::SortEntryVector>
+    {
+        using type = Windows::Foundation::Collections::IVector<Windows::Storage::Search::SortEntry>;
+    };
+    template <> struct default_interface<Windows::Storage::Search::StorageFileQueryResult>
+    {
+        using type = Windows::Storage::Search::IStorageFileQueryResult;
+    };
+    template <> struct default_interface<Windows::Storage::Search::StorageFolderQueryResult>
+    {
+        using type = Windows::Storage::Search::IStorageFolderQueryResult;
+    };
+    template <> struct default_interface<Windows::Storage::Search::StorageItemQueryResult>
+    {
+        using type = Windows::Storage::Search::IStorageItemQueryResult;
+    };
+    template <> struct default_interface<Windows::Storage::Search::StorageLibraryChangeTrackerTriggerDetails>
+    {
+        using type = Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails;
+    };
+    template <> struct default_interface<Windows::Storage::Search::StorageLibraryContentChangedTriggerDetails>
+    {
+        using type = Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails;
+    };
+    template <> struct default_interface<Windows::Storage::Search::ValueAndLanguage>
+    {
+        using type = Windows::Storage::Search::IValueAndLanguage;
+    };
+    template <> struct abi<Windows::Storage::Search::IContentIndexer>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall AddAsync(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall UpdateAsync(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall DeleteAsync(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall DeleteMultipleAsync(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall DeleteAllAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall RetrievePropertiesAsync(void*, void*, void**) noexcept = 0;
+            virtual int32_t __stdcall get_Revision(uint64_t*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IContentIndexerQuery>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetCountAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall GetPropertiesAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall GetPropertiesRangeAsync(uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall GetRangeAsync(uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall get_QueryFolder(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IContentIndexerQueryOperations>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall CreateQueryWithSortOrderAndLanguage(void*, void*, void*, void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateQueryWithSortOrder(void*, void*, void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateQuery(void*, void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IContentIndexerStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetIndexerWithName(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall GetIndexer(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IIndexableContent>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Id(void**) noexcept = 0;
+            virtual int32_t __stdcall put_Id(void*) noexcept = 0;
+            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
+            virtual int32_t __stdcall get_Stream(void**) noexcept = 0;
+            virtual int32_t __stdcall put_Stream(void*) noexcept = 0;
+            virtual int32_t __stdcall get_StreamContentType(void**) noexcept = 0;
+            virtual int32_t __stdcall put_StreamContentType(void*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IQueryOptions>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_FileTypeFilter(void**) noexcept = 0;
+            virtual int32_t __stdcall get_FolderDepth(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_FolderDepth(int32_t) noexcept = 0;
+            virtual int32_t __stdcall get_ApplicationSearchFilter(void**) noexcept = 0;
+            virtual int32_t __stdcall put_ApplicationSearchFilter(void*) noexcept = 0;
+            virtual int32_t __stdcall get_UserSearchFilter(void**) noexcept = 0;
+            virtual int32_t __stdcall put_UserSearchFilter(void*) noexcept = 0;
+            virtual int32_t __stdcall get_Language(void**) noexcept = 0;
+            virtual int32_t __stdcall put_Language(void*) noexcept = 0;
+            virtual int32_t __stdcall get_IndexerOption(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_IndexerOption(int32_t) noexcept = 0;
+            virtual int32_t __stdcall get_SortOrder(void**) noexcept = 0;
+            virtual int32_t __stdcall get_GroupPropertyName(void**) noexcept = 0;
+            virtual int32_t __stdcall get_DateStackOption(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall SaveToString(void**) noexcept = 0;
+            virtual int32_t __stdcall LoadFromString(void*) noexcept = 0;
+            virtual int32_t __stdcall SetThumbnailPrefetch(int32_t, uint32_t, uint32_t) noexcept = 0;
+            virtual int32_t __stdcall SetPropertyPrefetch(uint32_t, void*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IQueryOptionsFactory>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall CreateCommonFileQuery(int32_t, void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateCommonFolderQuery(int32_t, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IQueryOptionsWithProviderFilter>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_StorageProviderIdFilter(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageFileQueryResult>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetFilesAsync(uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetFilesAsyncDefaultStartAndCount(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageFileQueryResult2>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetMatchingPropertiesWithRanges(void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageFolderQueryOperations>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetIndexedStateAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFileQueryOverloadDefault(void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFileQuery(int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFileQueryWithOptions(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFolderQueryOverloadDefault(void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFolderQuery(int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFolderQueryWithOptions(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateItemQuery(void**) noexcept = 0;
+            virtual int32_t __stdcall CreateItemQueryWithOptions(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall GetFilesAsync(int32_t, uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetFilesAsyncOverloadDefaultStartAndCount(int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetFoldersAsync(int32_t, uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetFoldersAsyncOverloadDefaultStartAndCount(int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetItemsAsync(uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall AreQueryOptionsSupported(void*, bool*) noexcept = 0;
+            virtual int32_t __stdcall IsCommonFolderQuerySupported(int32_t, bool*) noexcept = 0;
+            virtual int32_t __stdcall IsCommonFileQuerySupported(int32_t, bool*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageFolderQueryResult>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetFoldersAsync(uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetFoldersAsyncDefaultStartAndCount(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageItemQueryResult>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetItemsAsync(uint32_t, uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetItemsAsyncDefaultStartAndCount(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Folder(void**) noexcept = 0;
+            virtual int32_t __stdcall get_ChangeTracker(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Folder(void**) noexcept = 0;
+            virtual int32_t __stdcall CreateModifiedSinceQuery(int64_t, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall GetItemCountAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall get_Folder(void**) noexcept = 0;
+            virtual int32_t __stdcall add_ContentsChanged(void*, winrt::event_token*) noexcept = 0;
+            virtual int32_t __stdcall remove_ContentsChanged(winrt::event_token) noexcept = 0;
+            virtual int32_t __stdcall add_OptionsChanged(void*, winrt::event_token*) noexcept = 0;
+            virtual int32_t __stdcall remove_OptionsChanged(winrt::event_token) noexcept = 0;
+            virtual int32_t __stdcall FindStartIndexAsync(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall GetCurrentQueryOptions(void**) noexcept = 0;
+            virtual int32_t __stdcall ApplyNewQueryOptions(void*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Search::IValueAndLanguage>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Language(void**) noexcept = 0;
+            virtual int32_t __stdcall put_Language(void*) noexcept = 0;
+            virtual int32_t __stdcall get_Value(void**) noexcept = 0;
+            virtual int32_t __stdcall put_Value(void*) noexcept = 0;
+        };
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IContentIndexer
+    {
+        auto AddAsync(Windows::Storage::Search::IIndexableContent const& indexableContent) const;
+        auto UpdateAsync(Windows::Storage::Search::IIndexableContent const& indexableContent) const;
+        auto DeleteAsync(param::hstring const& contentId) const;
+        auto DeleteMultipleAsync(param::async_iterable<hstring> const& contentIds) const;
+        auto DeleteAllAsync() const;
+        auto RetrievePropertiesAsync(param::hstring const& contentId, param::async_iterable<hstring> const& propertiesToRetrieve) const;
+        [[nodiscard]] auto Revision() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IContentIndexer>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IContentIndexer<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IContentIndexerQuery
+    {
+        auto GetCountAsync() const;
+        auto GetPropertiesAsync() const;
+        auto GetPropertiesAsync(uint32_t startIndex, uint32_t maxItems) const;
+        auto GetAsync() const;
+        auto GetAsync(uint32_t startIndex, uint32_t maxItems) const;
+        [[nodiscard]] auto QueryFolder() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IContentIndexerQuery>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IContentIndexerQuery<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IContentIndexerQueryOperations
+    {
+        auto CreateQuery(param::hstring const& searchFilter, param::iterable<hstring> const& propertiesToRetrieve, param::iterable<Windows::Storage::Search::SortEntry> const& sortOrder, param::hstring const& searchFilterLanguage) const;
+        auto CreateQuery(param::hstring const& searchFilter, param::iterable<hstring> const& propertiesToRetrieve, param::iterable<Windows::Storage::Search::SortEntry> const& sortOrder) const;
+        auto CreateQuery(param::hstring const& searchFilter, param::iterable<hstring> const& propertiesToRetrieve) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IContentIndexerQueryOperations>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IContentIndexerQueryOperations<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IContentIndexerStatics
+    {
+        auto GetIndexer(param::hstring const& indexName) const;
+        auto GetIndexer() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IContentIndexerStatics>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IContentIndexerStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IIndexableContent
+    {
+        [[nodiscard]] auto Id() const;
+        auto Id(param::hstring const& value) const;
+        [[nodiscard]] auto Properties() const;
+        [[nodiscard]] auto Stream() const;
+        auto Stream(Windows::Storage::Streams::IRandomAccessStream const& value) const;
+        [[nodiscard]] auto StreamContentType() const;
+        auto StreamContentType(param::hstring const& value) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IIndexableContent>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IIndexableContent<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IQueryOptions
+    {
+        [[nodiscard]] auto FileTypeFilter() const;
+        [[nodiscard]] auto FolderDepth() const;
+        auto FolderDepth(Windows::Storage::Search::FolderDepth const& value) const;
+        [[nodiscard]] auto ApplicationSearchFilter() const;
+        auto ApplicationSearchFilter(param::hstring const& value) const;
+        [[nodiscard]] auto UserSearchFilter() const;
+        auto UserSearchFilter(param::hstring const& value) const;
+        [[nodiscard]] auto Language() const;
+        auto Language(param::hstring const& value) const;
+        [[nodiscard]] auto IndexerOption() const;
+        auto IndexerOption(Windows::Storage::Search::IndexerOption const& value) const;
+        [[nodiscard]] auto SortOrder() const;
+        [[nodiscard]] auto GroupPropertyName() const;
+        [[nodiscard]] auto DateStackOption() const;
+        auto SaveToString() const;
+        auto LoadFromString(param::hstring const& value) const;
+        auto SetThumbnailPrefetch(Windows::Storage::FileProperties::ThumbnailMode const& mode, uint32_t requestedSize, Windows::Storage::FileProperties::ThumbnailOptions const& options) const;
+        auto SetPropertyPrefetch(Windows::Storage::FileProperties::PropertyPrefetchOptions const& options, param::iterable<hstring> const& propertiesToRetrieve) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IQueryOptions>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IQueryOptions<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IQueryOptionsFactory
+    {
+        auto CreateCommonFileQuery(Windows::Storage::Search::CommonFileQuery const& query, param::iterable<hstring> const& fileTypeFilter) const;
+        auto CreateCommonFolderQuery(Windows::Storage::Search::CommonFolderQuery const& query) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IQueryOptionsFactory>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IQueryOptionsFactory<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IQueryOptionsWithProviderFilter
+    {
+        [[nodiscard]] auto StorageProviderIdFilter() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IQueryOptionsWithProviderFilter>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IQueryOptionsWithProviderFilter<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageFileQueryResult
+    {
+        auto GetFilesAsync(uint32_t startIndex, uint32_t maxNumberOfItems) const;
+        auto GetFilesAsync() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageFileQueryResult>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageFileQueryResult<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageFileQueryResult2
+    {
+        auto GetMatchingPropertiesWithRanges(Windows::Storage::StorageFile const& file) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageFileQueryResult2>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageFileQueryResult2<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageFolderQueryOperations
+    {
+        auto GetIndexedStateAsync() const;
+        auto CreateFileQuery() const;
+        auto CreateFileQuery(Windows::Storage::Search::CommonFileQuery const& query) const;
+        auto CreateFileQueryWithOptions(Windows::Storage::Search::QueryOptions const& queryOptions) const;
+        auto CreateFolderQuery() const;
+        auto CreateFolderQuery(Windows::Storage::Search::CommonFolderQuery const& query) const;
+        auto CreateFolderQueryWithOptions(Windows::Storage::Search::QueryOptions const& queryOptions) const;
+        auto CreateItemQuery() const;
+        auto CreateItemQueryWithOptions(Windows::Storage::Search::QueryOptions const& queryOptions) const;
+        auto GetFilesAsync(Windows::Storage::Search::CommonFileQuery const& query, uint32_t startIndex, uint32_t maxItemsToRetrieve) const;
+        auto GetFilesAsync(Windows::Storage::Search::CommonFileQuery const& query) const;
+        auto GetFoldersAsync(Windows::Storage::Search::CommonFolderQuery const& query, uint32_t startIndex, uint32_t maxItemsToRetrieve) const;
+        auto GetFoldersAsync(Windows::Storage::Search::CommonFolderQuery const& query) const;
+        auto GetItemsAsync(uint32_t startIndex, uint32_t maxItemsToRetrieve) const;
+        auto AreQueryOptionsSupported(Windows::Storage::Search::QueryOptions const& queryOptions) const;
+        auto IsCommonFolderQuerySupported(Windows::Storage::Search::CommonFolderQuery const& query) const;
+        auto IsCommonFileQuerySupported(Windows::Storage::Search::CommonFileQuery const& query) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageFolderQueryOperations>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageFolderQueryOperations<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageFolderQueryResult
+    {
+        auto GetFoldersAsync(uint32_t startIndex, uint32_t maxNumberOfItems) const;
+        auto GetFoldersAsync() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageFolderQueryResult>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageFolderQueryResult<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageItemQueryResult
+    {
+        auto GetItemsAsync(uint32_t startIndex, uint32_t maxNumberOfItems) const;
+        auto GetItemsAsync() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageItemQueryResult>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageItemQueryResult<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageLibraryChangeTrackerTriggerDetails
+    {
+        [[nodiscard]] auto Folder() const;
+        [[nodiscard]] auto ChangeTracker() const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageLibraryChangeTrackerTriggerDetails<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageLibraryContentChangedTriggerDetails
+    {
+        [[nodiscard]] auto Folder() const;
+        auto CreateModifiedSinceQuery(Windows::Foundation::DateTime const& lastQueryTime) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageLibraryContentChangedTriggerDetails<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IStorageQueryResultBase
+    {
+        auto GetItemCountAsync() const;
+        [[nodiscard]] auto Folder() const;
+        auto ContentsChanged(Windows::Foundation::TypedEventHandler<Windows::Storage::Search::IStorageQueryResultBase, Windows::Foundation::IInspectable> const& handler) const;
+        using ContentsChanged_revoker = impl::event_revoker<Windows::Storage::Search::IStorageQueryResultBase, &impl::abi_t<Windows::Storage::Search::IStorageQueryResultBase>::remove_ContentsChanged>;
+        ContentsChanged_revoker ContentsChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Storage::Search::IStorageQueryResultBase, Windows::Foundation::IInspectable> const& handler) const;
+        auto ContentsChanged(winrt::event_token const& eventCookie) const noexcept;
+        auto OptionsChanged(Windows::Foundation::TypedEventHandler<Windows::Storage::Search::IStorageQueryResultBase, Windows::Foundation::IInspectable> const& changedHandler) const;
+        using OptionsChanged_revoker = impl::event_revoker<Windows::Storage::Search::IStorageQueryResultBase, &impl::abi_t<Windows::Storage::Search::IStorageQueryResultBase>::remove_OptionsChanged>;
+        OptionsChanged_revoker OptionsChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Storage::Search::IStorageQueryResultBase, Windows::Foundation::IInspectable> const& changedHandler) const;
+        auto OptionsChanged(winrt::event_token const& eventCookie) const noexcept;
+        auto FindStartIndexAsync(Windows::Foundation::IInspectable const& value) const;
+        auto GetCurrentQueryOptions() const;
+        auto ApplyNewQueryOptions(Windows::Storage::Search::QueryOptions const& newQueryOptions) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IStorageQueryResultBase<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Search_IValueAndLanguage
+    {
+        [[nodiscard]] auto Language() const;
+        auto Language(param::hstring const& value) const;
+        [[nodiscard]] auto Value() const;
+        auto Value(Windows::Foundation::IInspectable const& value) const;
+    };
+    template <> struct consume<Windows::Storage::Search::IValueAndLanguage>
+    {
+        template <typename D> using type = consume_Windows_Storage_Search_IValueAndLanguage<D>;
+    };
+    struct struct_Windows_Storage_Search_SortEntry
+    {
+        void* PropertyName;
+        bool AscendingOrder;
+    };
+    template <> struct abi<Windows::Storage::Search::SortEntry>
+    {
+        using type = struct_Windows_Storage_Search_SortEntry;
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.Search.1.h

@@ -0,0 +1,135 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_Search_1_H
+#define WINRT_Windows_Storage_Search_1_H
+#include "Windows.Storage.Search.0.h"
+namespace winrt::Windows::Storage::Search
+{
+    struct __declspec(empty_bases) IContentIndexer :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IContentIndexer>
+    {
+        IContentIndexer(std::nullptr_t = nullptr) noexcept {}
+        IContentIndexer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IContentIndexerQuery :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IContentIndexerQuery>
+    {
+        IContentIndexerQuery(std::nullptr_t = nullptr) noexcept {}
+        IContentIndexerQuery(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IContentIndexerQueryOperations :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IContentIndexerQueryOperations>
+    {
+        IContentIndexerQueryOperations(std::nullptr_t = nullptr) noexcept {}
+        IContentIndexerQueryOperations(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IContentIndexerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IContentIndexerStatics>
+    {
+        IContentIndexerStatics(std::nullptr_t = nullptr) noexcept {}
+        IContentIndexerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IIndexableContent :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IIndexableContent>
+    {
+        IIndexableContent(std::nullptr_t = nullptr) noexcept {}
+        IIndexableContent(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IQueryOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IQueryOptions>
+    {
+        IQueryOptions(std::nullptr_t = nullptr) noexcept {}
+        IQueryOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IQueryOptionsFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IQueryOptionsFactory>
+    {
+        IQueryOptionsFactory(std::nullptr_t = nullptr) noexcept {}
+        IQueryOptionsFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IQueryOptionsWithProviderFilter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IQueryOptionsWithProviderFilter>
+    {
+        IQueryOptionsWithProviderFilter(std::nullptr_t = nullptr) noexcept {}
+        IQueryOptionsWithProviderFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFileQueryResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFileQueryResult>,
+        impl::require<Windows::Storage::Search::IStorageFileQueryResult, Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        IStorageFileQueryResult(std::nullptr_t = nullptr) noexcept {}
+        IStorageFileQueryResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFileQueryResult2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFileQueryResult2>,
+        impl::require<Windows::Storage::Search::IStorageFileQueryResult2, Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        IStorageFileQueryResult2(std::nullptr_t = nullptr) noexcept {}
+        IStorageFileQueryResult2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFolderQueryOperations :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFolderQueryOperations>
+    {
+        IStorageFolderQueryOperations(std::nullptr_t = nullptr) noexcept {}
+        IStorageFolderQueryOperations(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageFolderQueryResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageFolderQueryResult>,
+        impl::require<Windows::Storage::Search::IStorageFolderQueryResult, Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        IStorageFolderQueryResult(std::nullptr_t = nullptr) noexcept {}
+        IStorageFolderQueryResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageItemQueryResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageItemQueryResult>,
+        impl::require<Windows::Storage::Search::IStorageItemQueryResult, Windows::Storage::Search::IStorageQueryResultBase>
+    {
+        IStorageItemQueryResult(std::nullptr_t = nullptr) noexcept {}
+        IStorageItemQueryResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibraryChangeTrackerTriggerDetails :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibraryChangeTrackerTriggerDetails>
+    {
+        IStorageLibraryChangeTrackerTriggerDetails(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibraryChangeTrackerTriggerDetails(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageLibraryContentChangedTriggerDetails :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageLibraryContentChangedTriggerDetails>
+    {
+        IStorageLibraryContentChangedTriggerDetails(std::nullptr_t = nullptr) noexcept {}
+        IStorageLibraryContentChangedTriggerDetails(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IStorageQueryResultBase :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IStorageQueryResultBase>
+    {
+        IStorageQueryResultBase(std::nullptr_t = nullptr) noexcept {}
+        IStorageQueryResultBase(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IValueAndLanguage :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IValueAndLanguage>
+    {
+        IValueAndLanguage(std::nullptr_t = nullptr) noexcept {}
+        IValueAndLanguage(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.Search.2.h

@@ -0,0 +1,91 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_Search_2_H
+#define WINRT_Windows_Storage_Search_2_H
+#include "Windows.Foundation.Collections.1.h"
+#include "Windows.Storage.Search.1.h"
+namespace winrt::Windows::Storage::Search
+{
+    struct SortEntry
+    {
+        hstring PropertyName;
+        bool AscendingOrder;
+    };
+    inline bool operator==(SortEntry const& left, SortEntry const& right) noexcept
+    {
+        return left.PropertyName == right.PropertyName && left.AscendingOrder == right.AscendingOrder;
+    }
+    inline bool operator!=(SortEntry const& left, SortEntry const& right) noexcept
+    {
+        return !(left == right);
+    }
+    struct __declspec(empty_bases) ContentIndexer : Windows::Storage::Search::IContentIndexer,
+        impl::require<ContentIndexer, Windows::Storage::Search::IContentIndexerQueryOperations>
+    {
+        ContentIndexer(std::nullptr_t) noexcept {}
+        ContentIndexer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IContentIndexer(ptr, take_ownership_from_abi) {}
+        static auto GetIndexer(param::hstring const& indexName);
+        static auto GetIndexer();
+    };
+    struct __declspec(empty_bases) ContentIndexerQuery : Windows::Storage::Search::IContentIndexerQuery
+    {
+        ContentIndexerQuery(std::nullptr_t) noexcept {}
+        ContentIndexerQuery(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IContentIndexerQuery(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IndexableContent : Windows::Storage::Search::IIndexableContent
+    {
+        IndexableContent(std::nullptr_t) noexcept {}
+        IndexableContent(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IIndexableContent(ptr, take_ownership_from_abi) {}
+        IndexableContent();
+    };
+    struct __declspec(empty_bases) QueryOptions : Windows::Storage::Search::IQueryOptions,
+        impl::require<QueryOptions, Windows::Storage::Search::IQueryOptionsWithProviderFilter>
+    {
+        QueryOptions(std::nullptr_t) noexcept {}
+        QueryOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IQueryOptions(ptr, take_ownership_from_abi) {}
+        QueryOptions();
+        QueryOptions(Windows::Storage::Search::CommonFileQuery const& query, param::iterable<hstring> const& fileTypeFilter);
+        QueryOptions(Windows::Storage::Search::CommonFolderQuery const& query);
+    };
+    struct __declspec(empty_bases) SortEntryVector : Windows::Foundation::Collections::IVector<Windows::Storage::Search::SortEntry>
+    {
+        SortEntryVector(std::nullptr_t) noexcept {}
+        SortEntryVector(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::Collections::IVector<Windows::Storage::Search::SortEntry>(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageFileQueryResult : Windows::Storage::Search::IStorageFileQueryResult,
+        impl::require<StorageFileQueryResult, Windows::Storage::Search::IStorageFileQueryResult2>
+    {
+        StorageFileQueryResult(std::nullptr_t) noexcept {}
+        StorageFileQueryResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IStorageFileQueryResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageFolderQueryResult : Windows::Storage::Search::IStorageFolderQueryResult
+    {
+        StorageFolderQueryResult(std::nullptr_t) noexcept {}
+        StorageFolderQueryResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IStorageFolderQueryResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageItemQueryResult : Windows::Storage::Search::IStorageItemQueryResult
+    {
+        StorageItemQueryResult(std::nullptr_t) noexcept {}
+        StorageItemQueryResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IStorageItemQueryResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageLibraryChangeTrackerTriggerDetails : Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails
+    {
+        StorageLibraryChangeTrackerTriggerDetails(std::nullptr_t) noexcept {}
+        StorageLibraryChangeTrackerTriggerDetails(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IStorageLibraryChangeTrackerTriggerDetails(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) StorageLibraryContentChangedTriggerDetails : Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails
+    {
+        StorageLibraryContentChangedTriggerDetails(std::nullptr_t) noexcept {}
+        StorageLibraryContentChangedTriggerDetails(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IStorageLibraryContentChangedTriggerDetails(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ValueAndLanguage : Windows::Storage::Search::IValueAndLanguage
+    {
+        ValueAndLanguage(std::nullptr_t) noexcept {}
+        ValueAndLanguage(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Search::IValueAndLanguage(ptr, take_ownership_from_abi) {}
+        ValueAndLanguage();
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.Streams.0.h

@@ -0,0 +1,941 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_Streams_0_H
+#define WINRT_Windows_Storage_Streams_0_H
+namespace winrt::Windows::Foundation
+{
+    template <typename TResult> struct IAsyncOperation;
+    struct IMemoryBuffer;
+    struct MemoryBuffer;
+    struct Uri;
+}
+namespace winrt::Windows::Storage
+{
+    enum class FileAccessMode : int32_t;
+    struct IStorageFile;
+    enum class StorageOpenOptions : uint32_t;
+}
+namespace winrt::Windows::System
+{
+    struct User;
+}
+namespace winrt::Windows::Storage::Streams
+{
+    enum class ByteOrder : int32_t
+    {
+        LittleEndian = 0,
+        BigEndian = 1,
+    };
+    enum class FileOpenDisposition : int32_t
+    {
+        OpenExisting = 0,
+        OpenAlways = 1,
+        CreateNew = 2,
+        CreateAlways = 3,
+        TruncateExisting = 4,
+    };
+    enum class InputStreamOptions : uint32_t
+    {
+        None = 0,
+        Partial = 0x1,
+        ReadAhead = 0x2,
+    };
+    enum class UnicodeEncoding : int32_t
+    {
+        Utf8 = 0,
+        Utf16LE = 1,
+        Utf16BE = 2,
+    };
+    struct IBuffer;
+    struct IBufferFactory;
+    struct IBufferStatics;
+    struct IContentTypeProvider;
+    struct IDataReader;
+    struct IDataReaderFactory;
+    struct IDataReaderStatics;
+    struct IDataWriter;
+    struct IDataWriterFactory;
+    struct IFileRandomAccessStreamStatics;
+    struct IInputStream;
+    struct IInputStreamReference;
+    struct IOutputStream;
+    struct IRandomAccessStream;
+    struct IRandomAccessStreamReference;
+    struct IRandomAccessStreamReferenceStatics;
+    struct IRandomAccessStreamStatics;
+    struct IRandomAccessStreamWithContentType;
+    struct Buffer;
+    struct DataReader;
+    struct DataReaderLoadOperation;
+    struct DataWriter;
+    struct DataWriterStoreOperation;
+    struct FileInputStream;
+    struct FileOutputStream;
+    struct FileRandomAccessStream;
+    struct InMemoryRandomAccessStream;
+    struct InputStreamOverStream;
+    struct OutputStreamOverStream;
+    struct RandomAccessStream;
+    struct RandomAccessStreamOverStream;
+    struct RandomAccessStreamReference;
+}
+namespace winrt::impl
+{
+    template <> struct category<Windows::Storage::Streams::IBuffer>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IBufferFactory>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IBufferStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IContentTypeProvider>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IDataReader>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IDataReaderFactory>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IDataReaderStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IDataWriter>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IDataWriterFactory>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IFileRandomAccessStreamStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IInputStream>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IInputStreamReference>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IOutputStream>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IRandomAccessStream>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IRandomAccessStreamReference>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IRandomAccessStreamReferenceStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IRandomAccessStreamStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::IRandomAccessStreamWithContentType>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::Storage::Streams::Buffer>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::DataReader>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::DataReaderLoadOperation>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::DataWriter>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::DataWriterStoreOperation>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::FileInputStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::FileOutputStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::FileRandomAccessStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::InMemoryRandomAccessStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::InputStreamOverStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::OutputStreamOverStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::RandomAccessStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::RandomAccessStreamOverStream>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::RandomAccessStreamReference>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::Storage::Streams::ByteOrder>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Streams::FileOpenDisposition>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Streams::InputStreamOptions>
+    {
+        using type = enum_category;
+    };
+    template <> struct category<Windows::Storage::Streams::UnicodeEncoding>
+    {
+        using type = enum_category;
+    };
+    template <> struct name<Windows::Storage::Streams::IBuffer>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IBuffer" };
+    };
+    template <> struct name<Windows::Storage::Streams::IBufferFactory>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IBufferFactory" };
+    };
+    template <> struct name<Windows::Storage::Streams::IBufferStatics>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IBufferStatics" };
+    };
+    template <> struct name<Windows::Storage::Streams::IContentTypeProvider>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IContentTypeProvider" };
+    };
+    template <> struct name<Windows::Storage::Streams::IDataReader>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IDataReader" };
+    };
+    template <> struct name<Windows::Storage::Streams::IDataReaderFactory>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IDataReaderFactory" };
+    };
+    template <> struct name<Windows::Storage::Streams::IDataReaderStatics>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IDataReaderStatics" };
+    };
+    template <> struct name<Windows::Storage::Streams::IDataWriter>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IDataWriter" };
+    };
+    template <> struct name<Windows::Storage::Streams::IDataWriterFactory>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IDataWriterFactory" };
+    };
+    template <> struct name<Windows::Storage::Streams::IFileRandomAccessStreamStatics>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IFileRandomAccessStreamStatics" };
+    };
+    template <> struct name<Windows::Storage::Streams::IInputStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IInputStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::IInputStreamReference>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IInputStreamReference" };
+    };
+    template <> struct name<Windows::Storage::Streams::IOutputStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IOutputStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::IRandomAccessStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IRandomAccessStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::IRandomAccessStreamReference>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IRandomAccessStreamReference" };
+    };
+    template <> struct name<Windows::Storage::Streams::IRandomAccessStreamReferenceStatics>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IRandomAccessStreamReferenceStatics" };
+    };
+    template <> struct name<Windows::Storage::Streams::IRandomAccessStreamStatics>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IRandomAccessStreamStatics" };
+    };
+    template <> struct name<Windows::Storage::Streams::IRandomAccessStreamWithContentType>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.IRandomAccessStreamWithContentType" };
+    };
+    template <> struct name<Windows::Storage::Streams::Buffer>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.Buffer" };
+    };
+    template <> struct name<Windows::Storage::Streams::DataReader>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.DataReader" };
+    };
+    template <> struct name<Windows::Storage::Streams::DataReaderLoadOperation>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.DataReaderLoadOperation" };
+    };
+    template <> struct name<Windows::Storage::Streams::DataWriter>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.DataWriter" };
+    };
+    template <> struct name<Windows::Storage::Streams::DataWriterStoreOperation>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.DataWriterStoreOperation" };
+    };
+    template <> struct name<Windows::Storage::Streams::FileInputStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.FileInputStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::FileOutputStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.FileOutputStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::FileRandomAccessStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.FileRandomAccessStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::InMemoryRandomAccessStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.InMemoryRandomAccessStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::InputStreamOverStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.InputStreamOverStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::OutputStreamOverStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.OutputStreamOverStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::RandomAccessStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.RandomAccessStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::RandomAccessStreamOverStream>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.RandomAccessStreamOverStream" };
+    };
+    template <> struct name<Windows::Storage::Streams::RandomAccessStreamReference>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.RandomAccessStreamReference" };
+    };
+    template <> struct name<Windows::Storage::Streams::ByteOrder>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.ByteOrder" };
+    };
+    template <> struct name<Windows::Storage::Streams::FileOpenDisposition>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.FileOpenDisposition" };
+    };
+    template <> struct name<Windows::Storage::Streams::InputStreamOptions>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.InputStreamOptions" };
+    };
+    template <> struct name<Windows::Storage::Streams::UnicodeEncoding>
+    {
+        static constexpr auto & value{ L"Windows.Storage.Streams.UnicodeEncoding" };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IBuffer>
+    {
+        static constexpr guid value{ 0x905A0FE0,0xBC53,0x11DF,{ 0x8C,0x49,0x00,0x1E,0x4F,0xC6,0x86,0xDA } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IBufferFactory>
+    {
+        static constexpr guid value{ 0x71AF914D,0xC10F,0x484B,{ 0xBC,0x50,0x14,0xBC,0x62,0x3B,0x3A,0x27 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IBufferStatics>
+    {
+        static constexpr guid value{ 0xE901E65B,0xD716,0x475A,{ 0xA9,0x0A,0xAF,0x72,0x29,0xB1,0xE7,0x41 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IContentTypeProvider>
+    {
+        static constexpr guid value{ 0x97D098A5,0x3B99,0x4DE9,{ 0x88,0xA5,0xE1,0x1D,0x2F,0x50,0xC7,0x95 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IDataReader>
+    {
+        static constexpr guid value{ 0xE2B50029,0xB4C1,0x4314,{ 0xA4,0xB8,0xFB,0x81,0x3A,0x2F,0x27,0x5E } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IDataReaderFactory>
+    {
+        static constexpr guid value{ 0xD7527847,0x57DA,0x4E15,{ 0x91,0x4C,0x06,0x80,0x66,0x99,0xA0,0x98 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IDataReaderStatics>
+    {
+        static constexpr guid value{ 0x11FCBFC8,0xF93A,0x471B,{ 0xB1,0x21,0xF3,0x79,0xE3,0x49,0x31,0x3C } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IDataWriter>
+    {
+        static constexpr guid value{ 0x64B89265,0xD341,0x4922,{ 0xB3,0x8A,0xDD,0x4A,0xF8,0x80,0x8C,0x4E } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IDataWriterFactory>
+    {
+        static constexpr guid value{ 0x338C67C2,0x8B84,0x4C2B,{ 0x9C,0x50,0x7B,0x87,0x67,0x84,0x7A,0x1F } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IFileRandomAccessStreamStatics>
+    {
+        static constexpr guid value{ 0x73550107,0x3B57,0x4B5D,{ 0x83,0x45,0x55,0x4D,0x2F,0xC6,0x21,0xF0 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IInputStream>
+    {
+        static constexpr guid value{ 0x905A0FE2,0xBC53,0x11DF,{ 0x8C,0x49,0x00,0x1E,0x4F,0xC6,0x86,0xDA } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IInputStreamReference>
+    {
+        static constexpr guid value{ 0x43929D18,0x5EC9,0x4B5A,{ 0x91,0x9C,0x42,0x05,0xB0,0xC8,0x04,0xB6 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IOutputStream>
+    {
+        static constexpr guid value{ 0x905A0FE6,0xBC53,0x11DF,{ 0x8C,0x49,0x00,0x1E,0x4F,0xC6,0x86,0xDA } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IRandomAccessStream>
+    {
+        static constexpr guid value{ 0x905A0FE1,0xBC53,0x11DF,{ 0x8C,0x49,0x00,0x1E,0x4F,0xC6,0x86,0xDA } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IRandomAccessStreamReference>
+    {
+        static constexpr guid value{ 0x33EE3134,0x1DD6,0x4E3A,{ 0x80,0x67,0xD1,0xC1,0x62,0xE8,0x64,0x2B } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IRandomAccessStreamReferenceStatics>
+    {
+        static constexpr guid value{ 0x857309DC,0x3FBF,0x4E7D,{ 0x98,0x6F,0xEF,0x3B,0x1A,0x07,0xA9,0x64 } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IRandomAccessStreamStatics>
+    {
+        static constexpr guid value{ 0x524CEDCF,0x6E29,0x4CE5,{ 0x95,0x73,0x6B,0x75,0x3D,0xB6,0x6C,0x3A } };
+    };
+    template <> struct guid_storage<Windows::Storage::Streams::IRandomAccessStreamWithContentType>
+    {
+        static constexpr guid value{ 0xCC254827,0x4B3D,0x438F,{ 0x92,0x32,0x10,0xC7,0x6B,0xC7,0xE0,0x38 } };
+    };
+    template <> struct default_interface<Windows::Storage::Streams::Buffer>
+    {
+        using type = Windows::Storage::Streams::IBuffer;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::DataReader>
+    {
+        using type = Windows::Storage::Streams::IDataReader;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::DataReaderLoadOperation>
+    {
+        using type = Windows::Foundation::IAsyncOperation<uint32_t>;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::DataWriter>
+    {
+        using type = Windows::Storage::Streams::IDataWriter;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::DataWriterStoreOperation>
+    {
+        using type = Windows::Foundation::IAsyncOperation<uint32_t>;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::FileInputStream>
+    {
+        using type = Windows::Storage::Streams::IInputStream;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::FileOutputStream>
+    {
+        using type = Windows::Storage::Streams::IOutputStream;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::FileRandomAccessStream>
+    {
+        using type = Windows::Storage::Streams::IRandomAccessStream;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::InMemoryRandomAccessStream>
+    {
+        using type = Windows::Storage::Streams::IRandomAccessStream;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::InputStreamOverStream>
+    {
+        using type = Windows::Storage::Streams::IInputStream;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::OutputStreamOverStream>
+    {
+        using type = Windows::Storage::Streams::IOutputStream;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::RandomAccessStreamOverStream>
+    {
+        using type = Windows::Storage::Streams::IRandomAccessStream;
+    };
+    template <> struct default_interface<Windows::Storage::Streams::RandomAccessStreamReference>
+    {
+        using type = Windows::Storage::Streams::IRandomAccessStreamReference;
+    };
+    template <> struct abi<Windows::Storage::Streams::IBuffer>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Capacity(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall get_Length(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_Length(uint32_t) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IBufferFactory>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall Create(uint32_t, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IBufferStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall CreateCopyFromMemoryBuffer(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateMemoryBufferOverIBuffer(void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IContentTypeProvider>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_ContentType(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IDataReader>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_UnconsumedBufferLength(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall get_UnicodeEncoding(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_UnicodeEncoding(int32_t) noexcept = 0;
+            virtual int32_t __stdcall get_ByteOrder(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_ByteOrder(int32_t) noexcept = 0;
+            virtual int32_t __stdcall get_InputStreamOptions(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_InputStreamOptions(uint32_t) noexcept = 0;
+            virtual int32_t __stdcall ReadByte(uint8_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadBytes(uint32_t, uint8_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadBuffer(uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall ReadBoolean(bool*) noexcept = 0;
+            virtual int32_t __stdcall ReadGuid(winrt::guid*) noexcept = 0;
+            virtual int32_t __stdcall ReadInt16(int16_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadInt32(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadInt64(int64_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadUInt16(uint16_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadUInt32(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadUInt64(uint64_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadSingle(float*) noexcept = 0;
+            virtual int32_t __stdcall ReadDouble(double*) noexcept = 0;
+            virtual int32_t __stdcall ReadString(uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall ReadDateTime(int64_t*) noexcept = 0;
+            virtual int32_t __stdcall ReadTimeSpan(int64_t*) noexcept = 0;
+            virtual int32_t __stdcall LoadAsync(uint32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall DetachBuffer(void**) noexcept = 0;
+            virtual int32_t __stdcall DetachStream(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IDataReaderFactory>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall CreateDataReader(void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IDataReaderStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall FromBuffer(void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IDataWriter>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_UnstoredBufferLength(uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall get_UnicodeEncoding(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_UnicodeEncoding(int32_t) noexcept = 0;
+            virtual int32_t __stdcall get_ByteOrder(int32_t*) noexcept = 0;
+            virtual int32_t __stdcall put_ByteOrder(int32_t) noexcept = 0;
+            virtual int32_t __stdcall WriteByte(uint8_t) noexcept = 0;
+            virtual int32_t __stdcall WriteBytes(uint32_t, uint8_t*) noexcept = 0;
+            virtual int32_t __stdcall WriteBuffer(void*) noexcept = 0;
+            virtual int32_t __stdcall WriteBufferRange(void*, uint32_t, uint32_t) noexcept = 0;
+            virtual int32_t __stdcall WriteBoolean(bool) noexcept = 0;
+            virtual int32_t __stdcall WriteGuid(winrt::guid) noexcept = 0;
+            virtual int32_t __stdcall WriteInt16(int16_t) noexcept = 0;
+            virtual int32_t __stdcall WriteInt32(int32_t) noexcept = 0;
+            virtual int32_t __stdcall WriteInt64(int64_t) noexcept = 0;
+            virtual int32_t __stdcall WriteUInt16(uint16_t) noexcept = 0;
+            virtual int32_t __stdcall WriteUInt32(uint32_t) noexcept = 0;
+            virtual int32_t __stdcall WriteUInt64(uint64_t) noexcept = 0;
+            virtual int32_t __stdcall WriteSingle(float) noexcept = 0;
+            virtual int32_t __stdcall WriteDouble(double) noexcept = 0;
+            virtual int32_t __stdcall WriteDateTime(int64_t) noexcept = 0;
+            virtual int32_t __stdcall WriteTimeSpan(int64_t) noexcept = 0;
+            virtual int32_t __stdcall WriteString(void*, uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall MeasureString(void*, uint32_t*) noexcept = 0;
+            virtual int32_t __stdcall StoreAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall FlushAsync(void**) noexcept = 0;
+            virtual int32_t __stdcall DetachBuffer(void**) noexcept = 0;
+            virtual int32_t __stdcall DetachStream(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IDataWriterFactory>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall CreateDataWriter(void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IFileRandomAccessStreamStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall OpenAsync(void*, int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall OpenWithOptionsAsync(void*, int32_t, uint32_t, int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall OpenTransactedWriteAsync(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall OpenTransactedWriteWithOptionsAsync(void*, uint32_t, int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall OpenForUserAsync(void*, void*, int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall OpenForUserWithOptionsAsync(void*, void*, int32_t, uint32_t, int32_t, void**) noexcept = 0;
+            virtual int32_t __stdcall OpenTransactedWriteForUserAsync(void*, void*, void**) noexcept = 0;
+            virtual int32_t __stdcall OpenTransactedWriteForUserWithOptionsAsync(void*, void*, uint32_t, int32_t, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IInputStream>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall ReadAsync(void*, uint32_t, uint32_t, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IInputStreamReference>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall OpenSequentialReadAsync(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IOutputStream>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall WriteAsync(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall FlushAsync(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IRandomAccessStream>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_Size(uint64_t*) noexcept = 0;
+            virtual int32_t __stdcall put_Size(uint64_t) noexcept = 0;
+            virtual int32_t __stdcall GetInputStreamAt(uint64_t, void**) noexcept = 0;
+            virtual int32_t __stdcall GetOutputStreamAt(uint64_t, void**) noexcept = 0;
+            virtual int32_t __stdcall get_Position(uint64_t*) noexcept = 0;
+            virtual int32_t __stdcall Seek(uint64_t) noexcept = 0;
+            virtual int32_t __stdcall CloneStream(void**) noexcept = 0;
+            virtual int32_t __stdcall get_CanRead(bool*) noexcept = 0;
+            virtual int32_t __stdcall get_CanWrite(bool*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IRandomAccessStreamReference>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall OpenReadAsync(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IRandomAccessStreamReferenceStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall CreateFromFile(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFromUri(void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CreateFromStream(void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IRandomAccessStreamStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall CopyAsync(void*, void*, void**) noexcept = 0;
+            virtual int32_t __stdcall CopySizeAsync(void*, void*, uint64_t, void**) noexcept = 0;
+            virtual int32_t __stdcall CopyAndCloseAsync(void*, void*, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::Storage::Streams::IRandomAccessStreamWithContentType>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+        };
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IBuffer
+    {
+        [[nodiscard]] auto Capacity() const;
+        [[nodiscard]] auto Length() const;
+        auto Length(uint32_t value) const;
+
+        auto data() const
+        {
+            uint8_t* data{};
+            static_cast<D const&>(*this).template as<IBufferByteAccess>()->Buffer(&data);
+            return data;
+        }
+    };
+    template <> struct consume<Windows::Storage::Streams::IBuffer>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IBuffer<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IBufferFactory
+    {
+        auto Create(uint32_t capacity) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IBufferFactory>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IBufferFactory<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IBufferStatics
+    {
+        auto CreateCopyFromMemoryBuffer(Windows::Foundation::IMemoryBuffer const& input) const;
+        auto CreateMemoryBufferOverIBuffer(Windows::Storage::Streams::IBuffer const& input) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IBufferStatics>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IBufferStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IContentTypeProvider
+    {
+        [[nodiscard]] auto ContentType() const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IContentTypeProvider>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IContentTypeProvider<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IDataReader
+    {
+        [[nodiscard]] auto UnconsumedBufferLength() const;
+        [[nodiscard]] auto UnicodeEncoding() const;
+        auto UnicodeEncoding(Windows::Storage::Streams::UnicodeEncoding const& value) const;
+        [[nodiscard]] auto ByteOrder() const;
+        auto ByteOrder(Windows::Storage::Streams::ByteOrder const& value) const;
+        [[nodiscard]] auto InputStreamOptions() const;
+        auto InputStreamOptions(Windows::Storage::Streams::InputStreamOptions const& value) const;
+        auto ReadByte() const;
+        auto ReadBytes(array_view<uint8_t> value) const;
+        auto ReadBuffer(uint32_t length) const;
+        auto ReadBoolean() const;
+        auto ReadGuid() const;
+        auto ReadInt16() const;
+        auto ReadInt32() const;
+        auto ReadInt64() const;
+        auto ReadUInt16() const;
+        auto ReadUInt32() const;
+        auto ReadUInt64() const;
+        auto ReadSingle() const;
+        auto ReadDouble() const;
+        auto ReadString(uint32_t codeUnitCount) const;
+        auto ReadDateTime() const;
+        auto ReadTimeSpan() const;
+        auto LoadAsync(uint32_t count) const;
+        auto DetachBuffer() const;
+        auto DetachStream() const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IDataReader>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IDataReader<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IDataReaderFactory
+    {
+        auto CreateDataReader(Windows::Storage::Streams::IInputStream const& inputStream) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IDataReaderFactory>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IDataReaderFactory<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IDataReaderStatics
+    {
+        auto FromBuffer(Windows::Storage::Streams::IBuffer const& buffer) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IDataReaderStatics>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IDataReaderStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IDataWriter
+    {
+        [[nodiscard]] auto UnstoredBufferLength() const;
+        [[nodiscard]] auto UnicodeEncoding() const;
+        auto UnicodeEncoding(Windows::Storage::Streams::UnicodeEncoding const& value) const;
+        [[nodiscard]] auto ByteOrder() const;
+        auto ByteOrder(Windows::Storage::Streams::ByteOrder const& value) const;
+        auto WriteByte(uint8_t value) const;
+        auto WriteBytes(array_view<uint8_t const> value) const;
+        auto WriteBuffer(Windows::Storage::Streams::IBuffer const& buffer) const;
+        auto WriteBuffer(Windows::Storage::Streams::IBuffer const& buffer, uint32_t start, uint32_t count) const;
+        auto WriteBoolean(bool value) const;
+        auto WriteGuid(winrt::guid const& value) const;
+        auto WriteInt16(int16_t value) const;
+        auto WriteInt32(int32_t value) const;
+        auto WriteInt64(int64_t value) const;
+        auto WriteUInt16(uint16_t value) const;
+        auto WriteUInt32(uint32_t value) const;
+        auto WriteUInt64(uint64_t value) const;
+        auto WriteSingle(float value) const;
+        auto WriteDouble(double value) const;
+        auto WriteDateTime(Windows::Foundation::DateTime const& value) const;
+        auto WriteTimeSpan(Windows::Foundation::TimeSpan const& value) const;
+        auto WriteString(param::hstring const& value) const;
+        auto MeasureString(param::hstring const& value) const;
+        auto StoreAsync() const;
+        auto FlushAsync() const;
+        auto DetachBuffer() const;
+        auto DetachStream() const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IDataWriter>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IDataWriter<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IDataWriterFactory
+    {
+        auto CreateDataWriter(Windows::Storage::Streams::IOutputStream const& outputStream) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IDataWriterFactory>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IDataWriterFactory<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IFileRandomAccessStreamStatics
+    {
+        auto OpenAsync(param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode) const;
+        auto OpenAsync(param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode, Windows::Storage::StorageOpenOptions const& sharingOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition) const;
+        auto OpenTransactedWriteAsync(param::hstring const& filePath) const;
+        auto OpenTransactedWriteAsync(param::hstring const& filePath, Windows::Storage::StorageOpenOptions const& openOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition) const;
+        auto OpenForUserAsync(Windows::System::User const& user, param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode) const;
+        auto OpenForUserAsync(Windows::System::User const& user, param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode, Windows::Storage::StorageOpenOptions const& sharingOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition) const;
+        auto OpenTransactedWriteForUserAsync(Windows::System::User const& user, param::hstring const& filePath) const;
+        auto OpenTransactedWriteForUserAsync(Windows::System::User const& user, param::hstring const& filePath, Windows::Storage::StorageOpenOptions const& openOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IFileRandomAccessStreamStatics>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IFileRandomAccessStreamStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IInputStream
+    {
+        auto ReadAsync(Windows::Storage::Streams::IBuffer const& buffer, uint32_t count, Windows::Storage::Streams::InputStreamOptions const& options) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IInputStream>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IInputStream<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IInputStreamReference
+    {
+        auto OpenSequentialReadAsync() const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IInputStreamReference>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IInputStreamReference<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IOutputStream
+    {
+        auto WriteAsync(Windows::Storage::Streams::IBuffer const& buffer) const;
+        auto FlushAsync() const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IOutputStream>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IOutputStream<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IRandomAccessStream
+    {
+        [[nodiscard]] auto Size() const;
+        auto Size(uint64_t value) const;
+        auto GetInputStreamAt(uint64_t position) const;
+        auto GetOutputStreamAt(uint64_t position) const;
+        [[nodiscard]] auto Position() const;
+        auto Seek(uint64_t position) const;
+        auto CloneStream() const;
+        [[nodiscard]] auto CanRead() const;
+        [[nodiscard]] auto CanWrite() const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IRandomAccessStream>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IRandomAccessStream<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IRandomAccessStreamReference
+    {
+        auto OpenReadAsync() const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IRandomAccessStreamReference>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IRandomAccessStreamReference<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IRandomAccessStreamReferenceStatics
+    {
+        auto CreateFromFile(Windows::Storage::IStorageFile const& file) const;
+        auto CreateFromUri(Windows::Foundation::Uri const& uri) const;
+        auto CreateFromStream(Windows::Storage::Streams::IRandomAccessStream const& stream) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IRandomAccessStreamReferenceStatics>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IRandomAccessStreamReferenceStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IRandomAccessStreamStatics
+    {
+        auto CopyAsync(Windows::Storage::Streams::IInputStream const& source, Windows::Storage::Streams::IOutputStream const& destination) const;
+        auto CopyAsync(Windows::Storage::Streams::IInputStream const& source, Windows::Storage::Streams::IOutputStream const& destination, uint64_t bytesToCopy) const;
+        auto CopyAndCloseAsync(Windows::Storage::Streams::IInputStream const& source, Windows::Storage::Streams::IOutputStream const& destination) const;
+    };
+    template <> struct consume<Windows::Storage::Streams::IRandomAccessStreamStatics>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IRandomAccessStreamStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_Storage_Streams_IRandomAccessStreamWithContentType
+    {
+    };
+    template <> struct consume<Windows::Storage::Streams::IRandomAccessStreamWithContentType>
+    {
+        template <typename D> using type = consume_Windows_Storage_Streams_IRandomAccessStreamWithContentType<D>;
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.Streams.1.h

@@ -0,0 +1,143 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_Streams_1_H
+#define WINRT_Windows_Storage_Streams_1_H
+#include "Windows.Foundation.0.h"
+#include "Windows.Storage.Streams.0.h"
+namespace winrt::Windows::Storage::Streams
+{
+    struct __declspec(empty_bases) IBuffer :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBuffer>
+    {
+        IBuffer(std::nullptr_t = nullptr) noexcept {}
+        IBuffer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBufferFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBufferFactory>
+    {
+        IBufferFactory(std::nullptr_t = nullptr) noexcept {}
+        IBufferFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBufferStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBufferStatics>
+    {
+        IBufferStatics(std::nullptr_t = nullptr) noexcept {}
+        IBufferStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IContentTypeProvider :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IContentTypeProvider>
+    {
+        IContentTypeProvider(std::nullptr_t = nullptr) noexcept {}
+        IContentTypeProvider(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDataReader :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDataReader>
+    {
+        IDataReader(std::nullptr_t = nullptr) noexcept {}
+        IDataReader(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDataReaderFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDataReaderFactory>
+    {
+        IDataReaderFactory(std::nullptr_t = nullptr) noexcept {}
+        IDataReaderFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDataReaderStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDataReaderStatics>
+    {
+        IDataReaderStatics(std::nullptr_t = nullptr) noexcept {}
+        IDataReaderStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDataWriter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDataWriter>
+    {
+        IDataWriter(std::nullptr_t = nullptr) noexcept {}
+        IDataWriter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDataWriterFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDataWriterFactory>
+    {
+        IDataWriterFactory(std::nullptr_t = nullptr) noexcept {}
+        IDataWriterFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IFileRandomAccessStreamStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IFileRandomAccessStreamStatics>
+    {
+        IFileRandomAccessStreamStatics(std::nullptr_t = nullptr) noexcept {}
+        IFileRandomAccessStreamStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IInputStream :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IInputStream>,
+        impl::require<Windows::Storage::Streams::IInputStream, Windows::Foundation::IClosable>
+    {
+        IInputStream(std::nullptr_t = nullptr) noexcept {}
+        IInputStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IInputStreamReference :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IInputStreamReference>
+    {
+        IInputStreamReference(std::nullptr_t = nullptr) noexcept {}
+        IInputStreamReference(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IOutputStream :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IOutputStream>,
+        impl::require<Windows::Storage::Streams::IOutputStream, Windows::Foundation::IClosable>
+    {
+        IOutputStream(std::nullptr_t = nullptr) noexcept {}
+        IOutputStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRandomAccessStream :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRandomAccessStream>,
+        impl::require<Windows::Storage::Streams::IRandomAccessStream, Windows::Foundation::IClosable, Windows::Storage::Streams::IInputStream, Windows::Storage::Streams::IOutputStream>
+    {
+        IRandomAccessStream(std::nullptr_t = nullptr) noexcept {}
+        IRandomAccessStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRandomAccessStreamReference :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRandomAccessStreamReference>
+    {
+        IRandomAccessStreamReference(std::nullptr_t = nullptr) noexcept {}
+        IRandomAccessStreamReference(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRandomAccessStreamReferenceStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRandomAccessStreamReferenceStatics>
+    {
+        IRandomAccessStreamReferenceStatics(std::nullptr_t = nullptr) noexcept {}
+        IRandomAccessStreamReferenceStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRandomAccessStreamStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRandomAccessStreamStatics>
+    {
+        IRandomAccessStreamStatics(std::nullptr_t = nullptr) noexcept {}
+        IRandomAccessStreamStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRandomAccessStreamWithContentType :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRandomAccessStreamWithContentType>,
+        impl::require<Windows::Storage::Streams::IRandomAccessStreamWithContentType, Windows::Foundation::IClosable, Windows::Storage::Streams::IInputStream, Windows::Storage::Streams::IOutputStream, Windows::Storage::Streams::IRandomAccessStream, Windows::Storage::Streams::IContentTypeProvider>
+    {
+        IRandomAccessStreamWithContentType(std::nullptr_t = nullptr) noexcept {}
+        IRandomAccessStreamWithContentType(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.Storage.Streams.2.h

@@ -0,0 +1,108 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_Storage_Streams_2_H
+#define WINRT_Windows_Storage_Streams_2_H
+#include "Windows.Foundation.1.h"
+#include "Windows.Storage.1.h"
+#include "Windows.System.1.h"
+#include "Windows.Storage.Streams.1.h"
+namespace winrt::Windows::Storage::Streams
+{
+    struct __declspec(empty_bases) Buffer : Windows::Storage::Streams::IBuffer
+    {
+        Buffer(std::nullptr_t) noexcept {}
+        Buffer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IBuffer(ptr, take_ownership_from_abi) {}
+        Buffer(uint32_t capacity);
+        static auto CreateCopyFromMemoryBuffer(Windows::Foundation::IMemoryBuffer const& input);
+        static auto CreateMemoryBufferOverIBuffer(Windows::Storage::Streams::IBuffer const& input);
+    };
+    struct __declspec(empty_bases) DataReader : Windows::Storage::Streams::IDataReader,
+        impl::require<DataReader, Windows::Foundation::IClosable>
+    {
+        DataReader(std::nullptr_t) noexcept {}
+        DataReader(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IDataReader(ptr, take_ownership_from_abi) {}
+        DataReader(Windows::Storage::Streams::IInputStream const& inputStream);
+        static auto FromBuffer(Windows::Storage::Streams::IBuffer const& buffer);
+    };
+    struct __declspec(empty_bases) DataReaderLoadOperation : Windows::Foundation::IAsyncOperation<uint32_t>
+    {
+        DataReaderLoadOperation(std::nullptr_t) noexcept {}
+        DataReaderLoadOperation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IAsyncOperation<uint32_t>(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) DataWriter : Windows::Storage::Streams::IDataWriter,
+        impl::require<DataWriter, Windows::Foundation::IClosable>
+    {
+        DataWriter(std::nullptr_t) noexcept {}
+        DataWriter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IDataWriter(ptr, take_ownership_from_abi) {}
+        DataWriter();
+        DataWriter(Windows::Storage::Streams::IOutputStream const& outputStream);
+    };
+    struct __declspec(empty_bases) DataWriterStoreOperation : Windows::Foundation::IAsyncOperation<uint32_t>
+    {
+        DataWriterStoreOperation(std::nullptr_t) noexcept {}
+        DataWriterStoreOperation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IAsyncOperation<uint32_t>(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) FileInputStream : Windows::Storage::Streams::IInputStream
+    {
+        FileInputStream(std::nullptr_t) noexcept {}
+        FileInputStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IInputStream(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) FileOutputStream : Windows::Storage::Streams::IOutputStream
+    {
+        FileOutputStream(std::nullptr_t) noexcept {}
+        FileOutputStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IOutputStream(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) FileRandomAccessStream : Windows::Storage::Streams::IRandomAccessStream
+    {
+        FileRandomAccessStream(std::nullptr_t) noexcept {}
+        FileRandomAccessStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IRandomAccessStream(ptr, take_ownership_from_abi) {}
+        static auto OpenAsync(param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode);
+        static auto OpenAsync(param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode, Windows::Storage::StorageOpenOptions const& sharingOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition);
+        static auto OpenTransactedWriteAsync(param::hstring const& filePath);
+        static auto OpenTransactedWriteAsync(param::hstring const& filePath, Windows::Storage::StorageOpenOptions const& openOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition);
+        static auto OpenForUserAsync(Windows::System::User const& user, param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode);
+        static auto OpenForUserAsync(Windows::System::User const& user, param::hstring const& filePath, Windows::Storage::FileAccessMode const& accessMode, Windows::Storage::StorageOpenOptions const& sharingOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition);
+        static auto OpenTransactedWriteForUserAsync(Windows::System::User const& user, param::hstring const& filePath);
+        static auto OpenTransactedWriteForUserAsync(Windows::System::User const& user, param::hstring const& filePath, Windows::Storage::StorageOpenOptions const& openOptions, Windows::Storage::Streams::FileOpenDisposition const& openDisposition);
+    };
+    struct __declspec(empty_bases) InMemoryRandomAccessStream : Windows::Storage::Streams::IRandomAccessStream
+    {
+        InMemoryRandomAccessStream(std::nullptr_t) noexcept {}
+        InMemoryRandomAccessStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IRandomAccessStream(ptr, take_ownership_from_abi) {}
+        InMemoryRandomAccessStream();
+    };
+    struct __declspec(empty_bases) InputStreamOverStream : Windows::Storage::Streams::IInputStream
+    {
+        InputStreamOverStream(std::nullptr_t) noexcept {}
+        InputStreamOverStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IInputStream(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) OutputStreamOverStream : Windows::Storage::Streams::IOutputStream
+    {
+        OutputStreamOverStream(std::nullptr_t) noexcept {}
+        OutputStreamOverStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IOutputStream(ptr, take_ownership_from_abi) {}
+    };
+    struct RandomAccessStream
+    {
+        RandomAccessStream() = delete;
+        static auto CopyAsync(Windows::Storage::Streams::IInputStream const& source, Windows::Storage::Streams::IOutputStream const& destination);
+        static auto CopyAsync(Windows::Storage::Streams::IInputStream const& source, Windows::Storage::Streams::IOutputStream const& destination, uint64_t bytesToCopy);
+        static auto CopyAndCloseAsync(Windows::Storage::Streams::IInputStream const& source, Windows::Storage::Streams::IOutputStream const& destination);
+    };
+    struct __declspec(empty_bases) RandomAccessStreamOverStream : Windows::Storage::Streams::IRandomAccessStream
+    {
+        RandomAccessStreamOverStream(std::nullptr_t) noexcept {}
+        RandomAccessStreamOverStream(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IRandomAccessStream(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RandomAccessStreamReference : Windows::Storage::Streams::IRandomAccessStreamReference
+    {
+        RandomAccessStreamReference(std::nullptr_t) noexcept {}
+        RandomAccessStreamReference(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Storage::Streams::IRandomAccessStreamReference(ptr, take_ownership_from_abi) {}
+        static auto CreateFromFile(Windows::Storage::IStorageFile const& file);
+        static auto CreateFromUri(Windows::Foundation::Uri const& uri);
+        static auto CreateFromStream(Windows::Storage::Streams::IRandomAccessStream const& stream);
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.System.1.h

@@ -0,0 +1,524 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_System_1_H
+#define WINRT_Windows_System_1_H
+#include "Windows.System.0.h"
+namespace winrt::Windows::System
+{
+    struct __declspec(empty_bases) IAppActivationResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppActivationResult>
+    {
+        IAppActivationResult(std::nullptr_t = nullptr) noexcept {}
+        IAppActivationResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDiagnosticInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDiagnosticInfo>
+    {
+        IAppDiagnosticInfo(std::nullptr_t = nullptr) noexcept {}
+        IAppDiagnosticInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDiagnosticInfo2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDiagnosticInfo2>
+    {
+        IAppDiagnosticInfo2(std::nullptr_t = nullptr) noexcept {}
+        IAppDiagnosticInfo2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDiagnosticInfo3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDiagnosticInfo3>
+    {
+        IAppDiagnosticInfo3(std::nullptr_t = nullptr) noexcept {}
+        IAppDiagnosticInfo3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDiagnosticInfoStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDiagnosticInfoStatics>
+    {
+        IAppDiagnosticInfoStatics(std::nullptr_t = nullptr) noexcept {}
+        IAppDiagnosticInfoStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDiagnosticInfoStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDiagnosticInfoStatics2>
+    {
+        IAppDiagnosticInfoStatics2(std::nullptr_t = nullptr) noexcept {}
+        IAppDiagnosticInfoStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDiagnosticInfoWatcher :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDiagnosticInfoWatcher>
+    {
+        IAppDiagnosticInfoWatcher(std::nullptr_t = nullptr) noexcept {}
+        IAppDiagnosticInfoWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppDiagnosticInfoWatcherEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppDiagnosticInfoWatcherEventArgs>
+    {
+        IAppDiagnosticInfoWatcherEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IAppDiagnosticInfoWatcherEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppExecutionStateChangeResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppExecutionStateChangeResult>
+    {
+        IAppExecutionStateChangeResult(std::nullptr_t = nullptr) noexcept {}
+        IAppExecutionStateChangeResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppMemoryReport :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppMemoryReport>
+    {
+        IAppMemoryReport(std::nullptr_t = nullptr) noexcept {}
+        IAppMemoryReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppMemoryReport2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppMemoryReport2>
+    {
+        IAppMemoryReport2(std::nullptr_t = nullptr) noexcept {}
+        IAppMemoryReport2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppMemoryUsageLimitChangingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppMemoryUsageLimitChangingEventArgs>
+    {
+        IAppMemoryUsageLimitChangingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IAppMemoryUsageLimitChangingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupBackgroundTaskReport :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupBackgroundTaskReport>
+    {
+        IAppResourceGroupBackgroundTaskReport(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupBackgroundTaskReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupInfo>
+    {
+        IAppResourceGroupInfo(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupInfo2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupInfo2>
+    {
+        IAppResourceGroupInfo2(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupInfo2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupInfoWatcher :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupInfoWatcher>
+    {
+        IAppResourceGroupInfoWatcher(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupInfoWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupInfoWatcherEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupInfoWatcherEventArgs>
+    {
+        IAppResourceGroupInfoWatcherEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupInfoWatcherEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs>
+    {
+        IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupMemoryReport :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupMemoryReport>
+    {
+        IAppResourceGroupMemoryReport(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupMemoryReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppResourceGroupStateReport :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppResourceGroupStateReport>
+    {
+        IAppResourceGroupStateReport(std::nullptr_t = nullptr) noexcept {}
+        IAppResourceGroupStateReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppUriHandlerHost :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppUriHandlerHost>
+    {
+        IAppUriHandlerHost(std::nullptr_t = nullptr) noexcept {}
+        IAppUriHandlerHost(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppUriHandlerHostFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppUriHandlerHostFactory>
+    {
+        IAppUriHandlerHostFactory(std::nullptr_t = nullptr) noexcept {}
+        IAppUriHandlerHostFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppUriHandlerRegistration :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppUriHandlerRegistration>
+    {
+        IAppUriHandlerRegistration(std::nullptr_t = nullptr) noexcept {}
+        IAppUriHandlerRegistration(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppUriHandlerRegistrationManager :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppUriHandlerRegistrationManager>
+    {
+        IAppUriHandlerRegistrationManager(std::nullptr_t = nullptr) noexcept {}
+        IAppUriHandlerRegistrationManager(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAppUriHandlerRegistrationManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAppUriHandlerRegistrationManagerStatics>
+    {
+        IAppUriHandlerRegistrationManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        IAppUriHandlerRegistrationManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDateTimeSettingsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDateTimeSettingsStatics>
+    {
+        IDateTimeSettingsStatics(std::nullptr_t = nullptr) noexcept {}
+        IDateTimeSettingsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDispatcherQueue :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDispatcherQueue>
+    {
+        IDispatcherQueue(std::nullptr_t = nullptr) noexcept {}
+        IDispatcherQueue(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDispatcherQueue2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDispatcherQueue2>
+    {
+        IDispatcherQueue2(std::nullptr_t = nullptr) noexcept {}
+        IDispatcherQueue2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDispatcherQueueController :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDispatcherQueueController>
+    {
+        IDispatcherQueueController(std::nullptr_t = nullptr) noexcept {}
+        IDispatcherQueueController(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDispatcherQueueControllerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDispatcherQueueControllerStatics>
+    {
+        IDispatcherQueueControllerStatics(std::nullptr_t = nullptr) noexcept {}
+        IDispatcherQueueControllerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDispatcherQueueShutdownStartingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDispatcherQueueShutdownStartingEventArgs>
+    {
+        IDispatcherQueueShutdownStartingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IDispatcherQueueShutdownStartingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDispatcherQueueStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDispatcherQueueStatics>
+    {
+        IDispatcherQueueStatics(std::nullptr_t = nullptr) noexcept {}
+        IDispatcherQueueStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IDispatcherQueueTimer :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IDispatcherQueueTimer>
+    {
+        IDispatcherQueueTimer(std::nullptr_t = nullptr) noexcept {}
+        IDispatcherQueueTimer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IFolderLauncherOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IFolderLauncherOptions>
+    {
+        IFolderLauncherOptions(std::nullptr_t = nullptr) noexcept {}
+        IFolderLauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownUserPropertiesStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownUserPropertiesStatics>
+    {
+        IKnownUserPropertiesStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownUserPropertiesStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILaunchUriResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILaunchUriResult>
+    {
+        ILaunchUriResult(std::nullptr_t = nullptr) noexcept {}
+        ILaunchUriResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherOptions>
+    {
+        ILauncherOptions(std::nullptr_t = nullptr) noexcept {}
+        ILauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherOptions2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherOptions2>
+    {
+        ILauncherOptions2(std::nullptr_t = nullptr) noexcept {}
+        ILauncherOptions2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherOptions3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherOptions3>
+    {
+        ILauncherOptions3(std::nullptr_t = nullptr) noexcept {}
+        ILauncherOptions3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherOptions4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherOptions4>
+    {
+        ILauncherOptions4(std::nullptr_t = nullptr) noexcept {}
+        ILauncherOptions4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherStatics>
+    {
+        ILauncherStatics(std::nullptr_t = nullptr) noexcept {}
+        ILauncherStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherStatics2>
+    {
+        ILauncherStatics2(std::nullptr_t = nullptr) noexcept {}
+        ILauncherStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherStatics3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherStatics3>
+    {
+        ILauncherStatics3(std::nullptr_t = nullptr) noexcept {}
+        ILauncherStatics3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherStatics4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherStatics4>
+    {
+        ILauncherStatics4(std::nullptr_t = nullptr) noexcept {}
+        ILauncherStatics4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherStatics5 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherStatics5>
+    {
+        ILauncherStatics5(std::nullptr_t = nullptr) noexcept {}
+        ILauncherStatics5(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherUIOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherUIOptions>
+    {
+        ILauncherUIOptions(std::nullptr_t = nullptr) noexcept {}
+        ILauncherUIOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ILauncherViewOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ILauncherViewOptions>
+    {
+        ILauncherViewOptions(std::nullptr_t = nullptr) noexcept {}
+        ILauncherViewOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IMemoryManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IMemoryManagerStatics>
+    {
+        IMemoryManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        IMemoryManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IMemoryManagerStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IMemoryManagerStatics2>
+    {
+        IMemoryManagerStatics2(std::nullptr_t = nullptr) noexcept {}
+        IMemoryManagerStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IMemoryManagerStatics3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IMemoryManagerStatics3>
+    {
+        IMemoryManagerStatics3(std::nullptr_t = nullptr) noexcept {}
+        IMemoryManagerStatics3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IMemoryManagerStatics4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IMemoryManagerStatics4>
+    {
+        IMemoryManagerStatics4(std::nullptr_t = nullptr) noexcept {}
+        IMemoryManagerStatics4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IProcessLauncherOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IProcessLauncherOptions>
+    {
+        IProcessLauncherOptions(std::nullptr_t = nullptr) noexcept {}
+        IProcessLauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IProcessLauncherResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IProcessLauncherResult>
+    {
+        IProcessLauncherResult(std::nullptr_t = nullptr) noexcept {}
+        IProcessLauncherResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IProcessLauncherStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IProcessLauncherStatics>
+    {
+        IProcessLauncherStatics(std::nullptr_t = nullptr) noexcept {}
+        IProcessLauncherStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IProcessMemoryReport :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IProcessMemoryReport>
+    {
+        IProcessMemoryReport(std::nullptr_t = nullptr) noexcept {}
+        IProcessMemoryReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IProtocolForResultsOperation :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IProtocolForResultsOperation>
+    {
+        IProtocolForResultsOperation(std::nullptr_t = nullptr) noexcept {}
+        IProtocolForResultsOperation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteLauncherOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteLauncherOptions>
+    {
+        IRemoteLauncherOptions(std::nullptr_t = nullptr) noexcept {}
+        IRemoteLauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteLauncherStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteLauncherStatics>
+    {
+        IRemoteLauncherStatics(std::nullptr_t = nullptr) noexcept {}
+        IRemoteLauncherStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IShutdownManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IShutdownManagerStatics>
+    {
+        IShutdownManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        IShutdownManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IShutdownManagerStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IShutdownManagerStatics2>,
+        impl::require<Windows::System::IShutdownManagerStatics2, Windows::System::IShutdownManagerStatics>
+    {
+        IShutdownManagerStatics2(std::nullptr_t = nullptr) noexcept {}
+        IShutdownManagerStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITimeZoneSettingsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITimeZoneSettingsStatics>
+    {
+        ITimeZoneSettingsStatics(std::nullptr_t = nullptr) noexcept {}
+        ITimeZoneSettingsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITimeZoneSettingsStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITimeZoneSettingsStatics2>
+    {
+        ITimeZoneSettingsStatics2(std::nullptr_t = nullptr) noexcept {}
+        ITimeZoneSettingsStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUser :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUser>
+    {
+        IUser(std::nullptr_t = nullptr) noexcept {}
+        IUser(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserAuthenticationStatusChangeDeferral :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserAuthenticationStatusChangeDeferral>
+    {
+        IUserAuthenticationStatusChangeDeferral(std::nullptr_t = nullptr) noexcept {}
+        IUserAuthenticationStatusChangeDeferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserAuthenticationStatusChangingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserAuthenticationStatusChangingEventArgs>
+    {
+        IUserAuthenticationStatusChangingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IUserAuthenticationStatusChangingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserChangedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserChangedEventArgs>
+    {
+        IUserChangedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IUserChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserChangedEventArgs2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserChangedEventArgs2>
+    {
+        IUserChangedEventArgs2(std::nullptr_t = nullptr) noexcept {}
+        IUserChangedEventArgs2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserDeviceAssociationChangedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserDeviceAssociationChangedEventArgs>
+    {
+        IUserDeviceAssociationChangedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IUserDeviceAssociationChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserDeviceAssociationStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserDeviceAssociationStatics>
+    {
+        IUserDeviceAssociationStatics(std::nullptr_t = nullptr) noexcept {}
+        IUserDeviceAssociationStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserPicker :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserPicker>
+    {
+        IUserPicker(std::nullptr_t = nullptr) noexcept {}
+        IUserPicker(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserPickerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserPickerStatics>
+    {
+        IUserPickerStatics(std::nullptr_t = nullptr) noexcept {}
+        IUserPickerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserStatics>
+    {
+        IUserStatics(std::nullptr_t = nullptr) noexcept {}
+        IUserStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserWatcher :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserWatcher>
+    {
+        IUserWatcher(std::nullptr_t = nullptr) noexcept {}
+        IUserWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.System.2.h

@@ -0,0 +1,355 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_System_2_H
+#define WINRT_Windows_System_2_H
+#include "Windows.Foundation.1.h"
+#include "Windows.Foundation.Collections.1.h"
+#include "Windows.Storage.1.h"
+#include "Windows.System.RemoteSystems.1.h"
+#include "Windows.System.1.h"
+namespace winrt::Windows::System
+{
+    struct DispatcherQueueHandler : Windows::Foundation::IUnknown
+    {
+        DispatcherQueueHandler(std::nullptr_t = nullptr) noexcept {}
+        DispatcherQueueHandler(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IUnknown(ptr, take_ownership_from_abi) {}
+        template <typename L> DispatcherQueueHandler(L lambda);
+        template <typename F> DispatcherQueueHandler(F* function);
+        template <typename O, typename M> DispatcherQueueHandler(O* object, M method);
+        template <typename O, typename M> DispatcherQueueHandler(com_ptr<O>&& object, M method);
+        template <typename O, typename M> DispatcherQueueHandler(weak_ref<O>&& object, M method);
+        auto operator()() const;
+    };
+    struct __declspec(empty_bases) AppActivationResult : Windows::System::IAppActivationResult
+    {
+        AppActivationResult(std::nullptr_t) noexcept {}
+        AppActivationResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppActivationResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppDiagnosticInfo : Windows::System::IAppDiagnosticInfo,
+        impl::require<AppDiagnosticInfo, Windows::System::IAppDiagnosticInfo2, Windows::System::IAppDiagnosticInfo3>
+    {
+        AppDiagnosticInfo(std::nullptr_t) noexcept {}
+        AppDiagnosticInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppDiagnosticInfo(ptr, take_ownership_from_abi) {}
+        static auto RequestInfoAsync();
+        static auto CreateWatcher();
+        static auto RequestAccessAsync();
+        static auto RequestInfoForPackageAsync(param::hstring const& packageFamilyName);
+        static auto RequestInfoForAppAsync();
+        static auto RequestInfoForAppAsync(param::hstring const& appUserModelId);
+    };
+    struct __declspec(empty_bases) AppDiagnosticInfoWatcher : Windows::System::IAppDiagnosticInfoWatcher
+    {
+        AppDiagnosticInfoWatcher(std::nullptr_t) noexcept {}
+        AppDiagnosticInfoWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppDiagnosticInfoWatcher(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppDiagnosticInfoWatcherEventArgs : Windows::System::IAppDiagnosticInfoWatcherEventArgs
+    {
+        AppDiagnosticInfoWatcherEventArgs(std::nullptr_t) noexcept {}
+        AppDiagnosticInfoWatcherEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppDiagnosticInfoWatcherEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppExecutionStateChangeResult : Windows::System::IAppExecutionStateChangeResult
+    {
+        AppExecutionStateChangeResult(std::nullptr_t) noexcept {}
+        AppExecutionStateChangeResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppExecutionStateChangeResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppMemoryReport : Windows::System::IAppMemoryReport,
+        impl::require<AppMemoryReport, Windows::System::IAppMemoryReport2>
+    {
+        AppMemoryReport(std::nullptr_t) noexcept {}
+        AppMemoryReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppMemoryReport(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppMemoryUsageLimitChangingEventArgs : Windows::System::IAppMemoryUsageLimitChangingEventArgs
+    {
+        AppMemoryUsageLimitChangingEventArgs(std::nullptr_t) noexcept {}
+        AppMemoryUsageLimitChangingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppMemoryUsageLimitChangingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppResourceGroupBackgroundTaskReport : Windows::System::IAppResourceGroupBackgroundTaskReport
+    {
+        AppResourceGroupBackgroundTaskReport(std::nullptr_t) noexcept {}
+        AppResourceGroupBackgroundTaskReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppResourceGroupBackgroundTaskReport(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppResourceGroupInfo : Windows::System::IAppResourceGroupInfo,
+        impl::require<AppResourceGroupInfo, Windows::System::IAppResourceGroupInfo2>
+    {
+        AppResourceGroupInfo(std::nullptr_t) noexcept {}
+        AppResourceGroupInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppResourceGroupInfo(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppResourceGroupInfoWatcher : Windows::System::IAppResourceGroupInfoWatcher
+    {
+        AppResourceGroupInfoWatcher(std::nullptr_t) noexcept {}
+        AppResourceGroupInfoWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppResourceGroupInfoWatcher(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppResourceGroupInfoWatcherEventArgs : Windows::System::IAppResourceGroupInfoWatcherEventArgs
+    {
+        AppResourceGroupInfoWatcherEventArgs(std::nullptr_t) noexcept {}
+        AppResourceGroupInfoWatcherEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppResourceGroupInfoWatcherEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppResourceGroupInfoWatcherExecutionStateChangedEventArgs : Windows::System::IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs
+    {
+        AppResourceGroupInfoWatcherExecutionStateChangedEventArgs(std::nullptr_t) noexcept {}
+        AppResourceGroupInfoWatcherExecutionStateChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppResourceGroupMemoryReport : Windows::System::IAppResourceGroupMemoryReport
+    {
+        AppResourceGroupMemoryReport(std::nullptr_t) noexcept {}
+        AppResourceGroupMemoryReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppResourceGroupMemoryReport(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppResourceGroupStateReport : Windows::System::IAppResourceGroupStateReport
+    {
+        AppResourceGroupStateReport(std::nullptr_t) noexcept {}
+        AppResourceGroupStateReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppResourceGroupStateReport(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppUriHandlerHost : Windows::System::IAppUriHandlerHost
+    {
+        AppUriHandlerHost(std::nullptr_t) noexcept {}
+        AppUriHandlerHost(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppUriHandlerHost(ptr, take_ownership_from_abi) {}
+        AppUriHandlerHost();
+        AppUriHandlerHost(param::hstring const& name);
+    };
+    struct __declspec(empty_bases) AppUriHandlerRegistration : Windows::System::IAppUriHandlerRegistration
+    {
+        AppUriHandlerRegistration(std::nullptr_t) noexcept {}
+        AppUriHandlerRegistration(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppUriHandlerRegistration(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) AppUriHandlerRegistrationManager : Windows::System::IAppUriHandlerRegistrationManager
+    {
+        AppUriHandlerRegistrationManager(std::nullptr_t) noexcept {}
+        AppUriHandlerRegistrationManager(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IAppUriHandlerRegistrationManager(ptr, take_ownership_from_abi) {}
+        static auto GetDefault();
+        static auto GetForUser(Windows::System::User const& user);
+    };
+    struct DateTimeSettings
+    {
+        DateTimeSettings() = delete;
+        static auto SetSystemDateTime(Windows::Foundation::DateTime const& utcDateTime);
+    };
+    struct __declspec(empty_bases) DispatcherQueue : Windows::System::IDispatcherQueue,
+        impl::require<DispatcherQueue, Windows::System::IDispatcherQueue2>
+    {
+        DispatcherQueue(std::nullptr_t) noexcept {}
+        DispatcherQueue(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IDispatcherQueue(ptr, take_ownership_from_abi) {}
+        static auto GetForCurrentThread();
+    };
+    struct __declspec(empty_bases) DispatcherQueueController : Windows::System::IDispatcherQueueController
+    {
+        DispatcherQueueController(std::nullptr_t) noexcept {}
+        DispatcherQueueController(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IDispatcherQueueController(ptr, take_ownership_from_abi) {}
+        static auto CreateOnDedicatedThread();
+    };
+    struct __declspec(empty_bases) DispatcherQueueShutdownStartingEventArgs : Windows::System::IDispatcherQueueShutdownStartingEventArgs
+    {
+        DispatcherQueueShutdownStartingEventArgs(std::nullptr_t) noexcept {}
+        DispatcherQueueShutdownStartingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IDispatcherQueueShutdownStartingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) DispatcherQueueTimer : Windows::System::IDispatcherQueueTimer
+    {
+        DispatcherQueueTimer(std::nullptr_t) noexcept {}
+        DispatcherQueueTimer(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IDispatcherQueueTimer(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) FolderLauncherOptions : Windows::System::IFolderLauncherOptions,
+        impl::require<FolderLauncherOptions, Windows::System::ILauncherViewOptions>
+    {
+        FolderLauncherOptions(std::nullptr_t) noexcept {}
+        FolderLauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IFolderLauncherOptions(ptr, take_ownership_from_abi) {}
+        FolderLauncherOptions();
+    };
+    struct KnownUserProperties
+    {
+        KnownUserProperties() = delete;
+        [[nodiscard]] static auto DisplayName();
+        [[nodiscard]] static auto FirstName();
+        [[nodiscard]] static auto LastName();
+        [[nodiscard]] static auto ProviderName();
+        [[nodiscard]] static auto AccountName();
+        [[nodiscard]] static auto GuestHost();
+        [[nodiscard]] static auto PrincipalName();
+        [[nodiscard]] static auto DomainName();
+        [[nodiscard]] static auto SessionInitiationProtocolUri();
+    };
+    struct __declspec(empty_bases) LaunchUriResult : Windows::System::ILaunchUriResult
+    {
+        LaunchUriResult(std::nullptr_t) noexcept {}
+        LaunchUriResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::ILaunchUriResult(ptr, take_ownership_from_abi) {}
+    };
+    struct Launcher
+    {
+        Launcher() = delete;
+        static auto LaunchFileAsync(Windows::Storage::IStorageFile const& file);
+        static auto LaunchFileAsync(Windows::Storage::IStorageFile const& file, Windows::System::LauncherOptions const& options);
+        static auto LaunchUriAsync(Windows::Foundation::Uri const& uri);
+        static auto LaunchUriAsync(Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options);
+        static auto LaunchUriForResultsAsync(Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options);
+        static auto LaunchUriForResultsAsync(Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options, Windows::Foundation::Collections::ValueSet const& inputData);
+        static auto LaunchUriAsync(Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options, Windows::Foundation::Collections::ValueSet const& inputData);
+        static auto QueryUriSupportAsync(Windows::Foundation::Uri const& uri, Windows::System::LaunchQuerySupportType const& launchQuerySupportType);
+        static auto QueryUriSupportAsync(Windows::Foundation::Uri const& uri, Windows::System::LaunchQuerySupportType const& launchQuerySupportType, param::hstring const& packageFamilyName);
+        static auto QueryFileSupportAsync(Windows::Storage::StorageFile const& file);
+        static auto QueryFileSupportAsync(Windows::Storage::StorageFile const& file, param::hstring const& packageFamilyName);
+        static auto FindUriSchemeHandlersAsync(param::hstring const& scheme);
+        static auto FindUriSchemeHandlersAsync(param::hstring const& scheme, Windows::System::LaunchQuerySupportType const& launchQuerySupportType);
+        static auto FindFileHandlersAsync(param::hstring const& extension);
+        static auto LaunchFolderAsync(Windows::Storage::IStorageFolder const& folder);
+        static auto LaunchFolderAsync(Windows::Storage::IStorageFolder const& folder, Windows::System::FolderLauncherOptions const& options);
+        static auto QueryAppUriSupportAsync(Windows::Foundation::Uri const& uri);
+        static auto QueryAppUriSupportAsync(Windows::Foundation::Uri const& uri, param::hstring const& packageFamilyName);
+        static auto FindAppUriHandlersAsync(Windows::Foundation::Uri const& uri);
+        static auto LaunchUriForUserAsync(Windows::System::User const& user, Windows::Foundation::Uri const& uri);
+        static auto LaunchUriForUserAsync(Windows::System::User const& user, Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options);
+        static auto LaunchUriForUserAsync(Windows::System::User const& user, Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options, Windows::Foundation::Collections::ValueSet const& inputData);
+        static auto LaunchUriForResultsForUserAsync(Windows::System::User const& user, Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options);
+        static auto LaunchUriForResultsForUserAsync(Windows::System::User const& user, Windows::Foundation::Uri const& uri, Windows::System::LauncherOptions const& options, Windows::Foundation::Collections::ValueSet const& inputData);
+        static auto LaunchFolderPathAsync(param::hstring const& path);
+        static auto LaunchFolderPathAsync(param::hstring const& path, Windows::System::FolderLauncherOptions const& options);
+        static auto LaunchFolderPathForUserAsync(Windows::System::User const& user, param::hstring const& path);
+        static auto LaunchFolderPathForUserAsync(Windows::System::User const& user, param::hstring const& path, Windows::System::FolderLauncherOptions const& options);
+    };
+    struct __declspec(empty_bases) LauncherOptions : Windows::System::ILauncherOptions,
+        impl::require<LauncherOptions, Windows::System::ILauncherOptions2, Windows::System::ILauncherOptions3, Windows::System::ILauncherOptions4, Windows::System::ILauncherViewOptions>
+    {
+        LauncherOptions(std::nullptr_t) noexcept {}
+        LauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::ILauncherOptions(ptr, take_ownership_from_abi) {}
+        LauncherOptions();
+    };
+    struct __declspec(empty_bases) LauncherUIOptions : Windows::System::ILauncherUIOptions
+    {
+        LauncherUIOptions(std::nullptr_t) noexcept {}
+        LauncherUIOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::ILauncherUIOptions(ptr, take_ownership_from_abi) {}
+    };
+    struct MemoryManager
+    {
+        MemoryManager() = delete;
+        [[nodiscard]] static auto AppMemoryUsage();
+        [[nodiscard]] static auto AppMemoryUsageLimit();
+        [[nodiscard]] static auto AppMemoryUsageLevel();
+        static auto AppMemoryUsageIncreased(Windows::Foundation::EventHandler<Windows::Foundation::IInspectable> const& handler);
+        using AppMemoryUsageIncreased_revoker = impl::factory_event_revoker<Windows::System::IMemoryManagerStatics, &impl::abi_t<Windows::System::IMemoryManagerStatics>::remove_AppMemoryUsageIncreased>;
+        static AppMemoryUsageIncreased_revoker AppMemoryUsageIncreased(auto_revoke_t, Windows::Foundation::EventHandler<Windows::Foundation::IInspectable> const& handler);
+        static auto AppMemoryUsageIncreased(winrt::event_token const& token);
+        static auto AppMemoryUsageDecreased(Windows::Foundation::EventHandler<Windows::Foundation::IInspectable> const& handler);
+        using AppMemoryUsageDecreased_revoker = impl::factory_event_revoker<Windows::System::IMemoryManagerStatics, &impl::abi_t<Windows::System::IMemoryManagerStatics>::remove_AppMemoryUsageDecreased>;
+        static AppMemoryUsageDecreased_revoker AppMemoryUsageDecreased(auto_revoke_t, Windows::Foundation::EventHandler<Windows::Foundation::IInspectable> const& handler);
+        static auto AppMemoryUsageDecreased(winrt::event_token const& token);
+        static auto AppMemoryUsageLimitChanging(Windows::Foundation::EventHandler<Windows::System::AppMemoryUsageLimitChangingEventArgs> const& handler);
+        using AppMemoryUsageLimitChanging_revoker = impl::factory_event_revoker<Windows::System::IMemoryManagerStatics, &impl::abi_t<Windows::System::IMemoryManagerStatics>::remove_AppMemoryUsageLimitChanging>;
+        static AppMemoryUsageLimitChanging_revoker AppMemoryUsageLimitChanging(auto_revoke_t, Windows::Foundation::EventHandler<Windows::System::AppMemoryUsageLimitChangingEventArgs> const& handler);
+        static auto AppMemoryUsageLimitChanging(winrt::event_token const& token);
+        static auto GetAppMemoryReport();
+        static auto GetProcessMemoryReport();
+        static auto TrySetAppMemoryUsageLimit(uint64_t value);
+        [[nodiscard]] static auto ExpectedAppMemoryUsageLimit();
+    };
+    struct ProcessLauncher
+    {
+        ProcessLauncher() = delete;
+        static auto RunToCompletionAsync(param::hstring const& fileName, param::hstring const& args);
+        static auto RunToCompletionAsync(param::hstring const& fileName, param::hstring const& args, Windows::System::ProcessLauncherOptions const& options);
+    };
+    struct __declspec(empty_bases) ProcessLauncherOptions : Windows::System::IProcessLauncherOptions
+    {
+        ProcessLauncherOptions(std::nullptr_t) noexcept {}
+        ProcessLauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IProcessLauncherOptions(ptr, take_ownership_from_abi) {}
+        ProcessLauncherOptions();
+    };
+    struct __declspec(empty_bases) ProcessLauncherResult : Windows::System::IProcessLauncherResult
+    {
+        ProcessLauncherResult(std::nullptr_t) noexcept {}
+        ProcessLauncherResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IProcessLauncherResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ProcessMemoryReport : Windows::System::IProcessMemoryReport
+    {
+        ProcessMemoryReport(std::nullptr_t) noexcept {}
+        ProcessMemoryReport(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IProcessMemoryReport(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ProtocolForResultsOperation : Windows::System::IProtocolForResultsOperation
+    {
+        ProtocolForResultsOperation(std::nullptr_t) noexcept {}
+        ProtocolForResultsOperation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IProtocolForResultsOperation(ptr, take_ownership_from_abi) {}
+    };
+    struct RemoteLauncher
+    {
+        RemoteLauncher() = delete;
+        static auto LaunchUriAsync(Windows::System::RemoteSystems::RemoteSystemConnectionRequest const& remoteSystemConnectionRequest, Windows::Foundation::Uri const& uri);
+        static auto LaunchUriAsync(Windows::System::RemoteSystems::RemoteSystemConnectionRequest const& remoteSystemConnectionRequest, Windows::Foundation::Uri const& uri, Windows::System::RemoteLauncherOptions const& options);
+        static auto LaunchUriAsync(Windows::System::RemoteSystems::RemoteSystemConnectionRequest const& remoteSystemConnectionRequest, Windows::Foundation::Uri const& uri, Windows::System::RemoteLauncherOptions const& options, Windows::Foundation::Collections::ValueSet const& inputData);
+    };
+    struct __declspec(empty_bases) RemoteLauncherOptions : Windows::System::IRemoteLauncherOptions
+    {
+        RemoteLauncherOptions(std::nullptr_t) noexcept {}
+        RemoteLauncherOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IRemoteLauncherOptions(ptr, take_ownership_from_abi) {}
+        RemoteLauncherOptions();
+    };
+    struct ShutdownManager
+    {
+        ShutdownManager() = delete;
+        static auto BeginShutdown(Windows::System::ShutdownKind const& shutdownKind, Windows::Foundation::TimeSpan const& timeout);
+        static auto CancelShutdown();
+        static auto IsPowerStateSupported(Windows::System::PowerState const& powerState);
+        static auto EnterPowerState(Windows::System::PowerState const& powerState);
+        static auto EnterPowerState(Windows::System::PowerState const& powerState, Windows::Foundation::TimeSpan const& wakeUpAfter);
+    };
+    struct TimeZoneSettings
+    {
+        TimeZoneSettings() = delete;
+        [[nodiscard]] static auto CurrentTimeZoneDisplayName();
+        [[nodiscard]] static auto SupportedTimeZoneDisplayNames();
+        [[nodiscard]] static auto CanChangeTimeZone();
+        static auto ChangeTimeZoneByDisplayName(param::hstring const& timeZoneDisplayName);
+        static auto AutoUpdateTimeZoneAsync(Windows::Foundation::TimeSpan const& timeout);
+    };
+    struct __declspec(empty_bases) User : Windows::System::IUser
+    {
+        User(std::nullptr_t) noexcept {}
+        User(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IUser(ptr, take_ownership_from_abi) {}
+        static auto CreateWatcher();
+        static auto FindAllAsync();
+        static auto FindAllAsync(Windows::System::UserType const& type);
+        static auto FindAllAsync(Windows::System::UserType const& type, Windows::System::UserAuthenticationStatus const& status);
+        static auto GetFromId(param::hstring const& nonRoamableId);
+    };
+    struct __declspec(empty_bases) UserAuthenticationStatusChangeDeferral : Windows::System::IUserAuthenticationStatusChangeDeferral
+    {
+        UserAuthenticationStatusChangeDeferral(std::nullptr_t) noexcept {}
+        UserAuthenticationStatusChangeDeferral(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IUserAuthenticationStatusChangeDeferral(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) UserAuthenticationStatusChangingEventArgs : Windows::System::IUserAuthenticationStatusChangingEventArgs
+    {
+        UserAuthenticationStatusChangingEventArgs(std::nullptr_t) noexcept {}
+        UserAuthenticationStatusChangingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IUserAuthenticationStatusChangingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) UserChangedEventArgs : Windows::System::IUserChangedEventArgs,
+        impl::require<UserChangedEventArgs, Windows::System::IUserChangedEventArgs2>
+    {
+        UserChangedEventArgs(std::nullptr_t) noexcept {}
+        UserChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IUserChangedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct UserDeviceAssociation
+    {
+        UserDeviceAssociation() = delete;
+        static auto FindUserFromDeviceId(param::hstring const& deviceId);
+        static auto UserDeviceAssociationChanged(Windows::Foundation::EventHandler<Windows::System::UserDeviceAssociationChangedEventArgs> const& handler);
+        using UserDeviceAssociationChanged_revoker = impl::factory_event_revoker<Windows::System::IUserDeviceAssociationStatics, &impl::abi_t<Windows::System::IUserDeviceAssociationStatics>::remove_UserDeviceAssociationChanged>;
+        static UserDeviceAssociationChanged_revoker UserDeviceAssociationChanged(auto_revoke_t, Windows::Foundation::EventHandler<Windows::System::UserDeviceAssociationChangedEventArgs> const& handler);
+        static auto UserDeviceAssociationChanged(winrt::event_token const& token);
+    };
+    struct __declspec(empty_bases) UserDeviceAssociationChangedEventArgs : Windows::System::IUserDeviceAssociationChangedEventArgs
+    {
+        UserDeviceAssociationChangedEventArgs(std::nullptr_t) noexcept {}
+        UserDeviceAssociationChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IUserDeviceAssociationChangedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) UserPicker : Windows::System::IUserPicker
+    {
+        UserPicker(std::nullptr_t) noexcept {}
+        UserPicker(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IUserPicker(ptr, take_ownership_from_abi) {}
+        UserPicker();
+        static auto IsSupported();
+    };
+    struct __declspec(empty_bases) UserWatcher : Windows::System::IUserWatcher
+    {
+        UserWatcher(std::nullptr_t) noexcept {}
+        UserWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::IUserWatcher(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.System.RemoteSystems.1.h

@@ -0,0 +1,488 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_System_RemoteSystems_1_H
+#define WINRT_Windows_System_RemoteSystems_1_H
+#include "Windows.System.RemoteSystems.0.h"
+namespace winrt::Windows::System::RemoteSystems
+{
+    struct __declspec(empty_bases) IKnownRemoteSystemCapabilitiesStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownRemoteSystemCapabilitiesStatics>
+    {
+        IKnownRemoteSystemCapabilitiesStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownRemoteSystemCapabilitiesStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystem :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystem>
+    {
+        IRemoteSystem(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystem(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystem2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystem2>
+    {
+        IRemoteSystem2(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystem2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystem3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystem3>
+    {
+        IRemoteSystem3(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystem3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystem4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystem4>
+    {
+        IRemoteSystem4(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystem4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystem5 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystem5>
+    {
+        IRemoteSystem5(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystem5(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystem6 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystem6>
+    {
+        IRemoteSystem6(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystem6(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemAddedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemAddedEventArgs>
+    {
+        IRemoteSystemAddedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemAddedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemApp :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemApp>
+    {
+        IRemoteSystemApp(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemApp(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemApp2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemApp2>
+    {
+        IRemoteSystemApp2(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemApp2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemAppRegistration :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemAppRegistration>
+    {
+        IRemoteSystemAppRegistration(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemAppRegistration(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemAppRegistrationStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemAppRegistrationStatics>
+    {
+        IRemoteSystemAppRegistrationStatics(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemAppRegistrationStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemAuthorizationKindFilter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemAuthorizationKindFilter>
+    {
+        IRemoteSystemAuthorizationKindFilter(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemAuthorizationKindFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemAuthorizationKindFilterFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemAuthorizationKindFilterFactory>
+    {
+        IRemoteSystemAuthorizationKindFilterFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemAuthorizationKindFilterFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionInfo>
+    {
+        IRemoteSystemConnectionInfo(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionInfoStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionInfoStatics>
+    {
+        IRemoteSystemConnectionInfoStatics(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionInfoStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionRequest :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionRequest>
+    {
+        IRemoteSystemConnectionRequest(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionRequest2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionRequest2>
+    {
+        IRemoteSystemConnectionRequest2(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionRequest2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionRequest3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionRequest3>
+    {
+        IRemoteSystemConnectionRequest3(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionRequest3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionRequestFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionRequestFactory>
+    {
+        IRemoteSystemConnectionRequestFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionRequestFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionRequestStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionRequestStatics>
+    {
+        IRemoteSystemConnectionRequestStatics(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionRequestStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemConnectionRequestStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemConnectionRequestStatics2>
+    {
+        IRemoteSystemConnectionRequestStatics2(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemConnectionRequestStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemDiscoveryTypeFilter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemDiscoveryTypeFilter>
+    {
+        IRemoteSystemDiscoveryTypeFilter(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemDiscoveryTypeFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemDiscoveryTypeFilterFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemDiscoveryTypeFilterFactory>
+    {
+        IRemoteSystemDiscoveryTypeFilterFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemDiscoveryTypeFilterFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemEnumerationCompletedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemEnumerationCompletedEventArgs>
+    {
+        IRemoteSystemEnumerationCompletedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemEnumerationCompletedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemFilter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemFilter>
+    {
+        IRemoteSystemFilter(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemKindFilter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemKindFilter>
+    {
+        IRemoteSystemKindFilter(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemKindFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemKindFilterFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemKindFilterFactory>
+    {
+        IRemoteSystemKindFilterFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemKindFilterFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemKindStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemKindStatics>
+    {
+        IRemoteSystemKindStatics(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemKindStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemKindStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemKindStatics2>
+    {
+        IRemoteSystemKindStatics2(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemKindStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemRemovedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemRemovedEventArgs>
+    {
+        IRemoteSystemRemovedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemRemovedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSession :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSession>
+    {
+        IRemoteSystemSession(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSession(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionAddedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionAddedEventArgs>
+    {
+        IRemoteSystemSessionAddedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionAddedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionController :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionController>
+    {
+        IRemoteSystemSessionController(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionController(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionControllerFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionControllerFactory>
+    {
+        IRemoteSystemSessionControllerFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionControllerFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionCreationResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionCreationResult>
+    {
+        IRemoteSystemSessionCreationResult(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionCreationResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionDisconnectedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionDisconnectedEventArgs>
+    {
+        IRemoteSystemSessionDisconnectedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionDisconnectedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionInfo :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionInfo>
+    {
+        IRemoteSystemSessionInfo(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionInvitation :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionInvitation>
+    {
+        IRemoteSystemSessionInvitation(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionInvitation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionInvitationListener :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionInvitationListener>
+    {
+        IRemoteSystemSessionInvitationListener(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionInvitationListener(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionInvitationReceivedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionInvitationReceivedEventArgs>
+    {
+        IRemoteSystemSessionInvitationReceivedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionInvitationReceivedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionJoinRequest :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionJoinRequest>
+    {
+        IRemoteSystemSessionJoinRequest(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionJoinRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionJoinRequestedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionJoinRequestedEventArgs>
+    {
+        IRemoteSystemSessionJoinRequestedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionJoinRequestedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionJoinResult :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionJoinResult>
+    {
+        IRemoteSystemSessionJoinResult(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionJoinResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionMessageChannel :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionMessageChannel>
+    {
+        IRemoteSystemSessionMessageChannel(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionMessageChannel(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionMessageChannelFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionMessageChannelFactory>
+    {
+        IRemoteSystemSessionMessageChannelFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionMessageChannelFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionOptions :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionOptions>
+    {
+        IRemoteSystemSessionOptions(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionParticipant :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionParticipant>
+    {
+        IRemoteSystemSessionParticipant(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionParticipant(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionParticipantAddedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionParticipantAddedEventArgs>
+    {
+        IRemoteSystemSessionParticipantAddedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionParticipantAddedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionParticipantRemovedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionParticipantRemovedEventArgs>
+    {
+        IRemoteSystemSessionParticipantRemovedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionParticipantRemovedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionParticipantWatcher :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionParticipantWatcher>
+    {
+        IRemoteSystemSessionParticipantWatcher(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionParticipantWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionRemovedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionRemovedEventArgs>
+    {
+        IRemoteSystemSessionRemovedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionRemovedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionStatics>
+    {
+        IRemoteSystemSessionStatics(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionUpdatedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionUpdatedEventArgs>
+    {
+        IRemoteSystemSessionUpdatedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionUpdatedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionValueSetReceivedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionValueSetReceivedEventArgs>
+    {
+        IRemoteSystemSessionValueSetReceivedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionValueSetReceivedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemSessionWatcher :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemSessionWatcher>
+    {
+        IRemoteSystemSessionWatcher(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemSessionWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemStatics>
+    {
+        IRemoteSystemStatics(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemStatics2>
+    {
+        IRemoteSystemStatics2(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemStatics3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemStatics3>
+    {
+        IRemoteSystemStatics3(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemStatics3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemStatusTypeFilter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemStatusTypeFilter>
+    {
+        IRemoteSystemStatusTypeFilter(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemStatusTypeFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemStatusTypeFilterFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemStatusTypeFilterFactory>
+    {
+        IRemoteSystemStatusTypeFilterFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemStatusTypeFilterFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemUpdatedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemUpdatedEventArgs>
+    {
+        IRemoteSystemUpdatedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemUpdatedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemWatcher :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemWatcher>
+    {
+        IRemoteSystemWatcher(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemWatcher2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemWatcher2>
+    {
+        IRemoteSystemWatcher2(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemWatcher2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemWatcher3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemWatcher3>
+    {
+        IRemoteSystemWatcher3(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemWatcher3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemWatcherErrorOccurredEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemWatcherErrorOccurredEventArgs>
+    {
+        IRemoteSystemWatcherErrorOccurredEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemWatcherErrorOccurredEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemWebAccountFilter :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemWebAccountFilter>
+    {
+        IRemoteSystemWebAccountFilter(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemWebAccountFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IRemoteSystemWebAccountFilterFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IRemoteSystemWebAccountFilterFactory>
+    {
+        IRemoteSystemWebAccountFilterFactory(std::nullptr_t = nullptr) noexcept {}
+        IRemoteSystemWebAccountFilterFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.System.RemoteSystems.2.h

@@ -0,0 +1,264 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_System_RemoteSystems_2_H
+#define WINRT_Windows_System_RemoteSystems_2_H
+#include "Windows.ApplicationModel.AppService.1.h"
+#include "Windows.Foundation.1.h"
+#include "Windows.Foundation.Collections.1.h"
+#include "Windows.Networking.1.h"
+#include "Windows.Security.Credentials.1.h"
+#include "Windows.System.1.h"
+#include "Windows.System.RemoteSystems.1.h"
+namespace winrt::Windows::System::RemoteSystems
+{
+    struct KnownRemoteSystemCapabilities
+    {
+        KnownRemoteSystemCapabilities() = delete;
+        [[nodiscard]] static auto AppService();
+        [[nodiscard]] static auto LaunchUri();
+        [[nodiscard]] static auto RemoteSession();
+        [[nodiscard]] static auto SpatialEntity();
+    };
+    struct __declspec(empty_bases) RemoteSystem : Windows::System::RemoteSystems::IRemoteSystem,
+        impl::require<RemoteSystem, Windows::System::RemoteSystems::IRemoteSystem2, Windows::System::RemoteSystems::IRemoteSystem3, Windows::System::RemoteSystems::IRemoteSystem4, Windows::System::RemoteSystems::IRemoteSystem5, Windows::System::RemoteSystems::IRemoteSystem6>
+    {
+        RemoteSystem(std::nullptr_t) noexcept {}
+        RemoteSystem(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystem(ptr, take_ownership_from_abi) {}
+        static auto FindByHostNameAsync(Windows::Networking::HostName const& hostName);
+        static auto CreateWatcher();
+        static auto CreateWatcher(param::iterable<Windows::System::RemoteSystems::IRemoteSystemFilter> const& filters);
+        static auto RequestAccessAsync();
+        static auto IsAuthorizationKindEnabled(Windows::System::RemoteSystems::RemoteSystemAuthorizationKind const& kind);
+        static auto CreateWatcherForUser(Windows::System::User const& user);
+        static auto CreateWatcherForUser(Windows::System::User const& user, param::iterable<Windows::System::RemoteSystems::IRemoteSystemFilter> const& filters);
+    };
+    struct __declspec(empty_bases) RemoteSystemAddedEventArgs : Windows::System::RemoteSystems::IRemoteSystemAddedEventArgs
+    {
+        RemoteSystemAddedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemAddedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemAddedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemApp : Windows::System::RemoteSystems::IRemoteSystemApp,
+        impl::require<RemoteSystemApp, Windows::System::RemoteSystems::IRemoteSystemApp2>
+    {
+        RemoteSystemApp(std::nullptr_t) noexcept {}
+        RemoteSystemApp(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemApp(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemAppRegistration : Windows::System::RemoteSystems::IRemoteSystemAppRegistration
+    {
+        RemoteSystemAppRegistration(std::nullptr_t) noexcept {}
+        RemoteSystemAppRegistration(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemAppRegistration(ptr, take_ownership_from_abi) {}
+        static auto GetDefault();
+        static auto GetForUser(Windows::System::User const& user);
+    };
+    struct __declspec(empty_bases) RemoteSystemAuthorizationKindFilter : Windows::System::RemoteSystems::IRemoteSystemAuthorizationKindFilter,
+        impl::require<RemoteSystemAuthorizationKindFilter, Windows::System::RemoteSystems::IRemoteSystemFilter>
+    {
+        RemoteSystemAuthorizationKindFilter(std::nullptr_t) noexcept {}
+        RemoteSystemAuthorizationKindFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemAuthorizationKindFilter(ptr, take_ownership_from_abi) {}
+        RemoteSystemAuthorizationKindFilter(Windows::System::RemoteSystems::RemoteSystemAuthorizationKind const& remoteSystemAuthorizationKind);
+    };
+    struct __declspec(empty_bases) RemoteSystemConnectionInfo : Windows::System::RemoteSystems::IRemoteSystemConnectionInfo
+    {
+        RemoteSystemConnectionInfo(std::nullptr_t) noexcept {}
+        RemoteSystemConnectionInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemConnectionInfo(ptr, take_ownership_from_abi) {}
+        static auto TryCreateFromAppServiceConnection(Windows::ApplicationModel::AppService::AppServiceConnection const& connection);
+    };
+    struct __declspec(empty_bases) RemoteSystemConnectionRequest : Windows::System::RemoteSystems::IRemoteSystemConnectionRequest,
+        impl::require<RemoteSystemConnectionRequest, Windows::System::RemoteSystems::IRemoteSystemConnectionRequest2, Windows::System::RemoteSystems::IRemoteSystemConnectionRequest3>
+    {
+        RemoteSystemConnectionRequest(std::nullptr_t) noexcept {}
+        RemoteSystemConnectionRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemConnectionRequest(ptr, take_ownership_from_abi) {}
+        RemoteSystemConnectionRequest(Windows::System::RemoteSystems::RemoteSystem const& remoteSystem);
+        static auto CreateForApp(Windows::System::RemoteSystems::RemoteSystemApp const& remoteSystemApp);
+        static auto CreateFromConnectionToken(param::hstring const& connectionToken);
+        static auto CreateFromConnectionTokenForUser(Windows::System::User const& user, param::hstring const& connectionToken);
+    };
+    struct __declspec(empty_bases) RemoteSystemDiscoveryTypeFilter : Windows::System::RemoteSystems::IRemoteSystemDiscoveryTypeFilter,
+        impl::require<RemoteSystemDiscoveryTypeFilter, Windows::System::RemoteSystems::IRemoteSystemFilter>
+    {
+        RemoteSystemDiscoveryTypeFilter(std::nullptr_t) noexcept {}
+        RemoteSystemDiscoveryTypeFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemDiscoveryTypeFilter(ptr, take_ownership_from_abi) {}
+        RemoteSystemDiscoveryTypeFilter(Windows::System::RemoteSystems::RemoteSystemDiscoveryType const& discoveryType);
+    };
+    struct __declspec(empty_bases) RemoteSystemEnumerationCompletedEventArgs : Windows::System::RemoteSystems::IRemoteSystemEnumerationCompletedEventArgs
+    {
+        RemoteSystemEnumerationCompletedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemEnumerationCompletedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemEnumerationCompletedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemKindFilter : Windows::System::RemoteSystems::IRemoteSystemKindFilter,
+        impl::require<RemoteSystemKindFilter, Windows::System::RemoteSystems::IRemoteSystemFilter>
+    {
+        RemoteSystemKindFilter(std::nullptr_t) noexcept {}
+        RemoteSystemKindFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemKindFilter(ptr, take_ownership_from_abi) {}
+        RemoteSystemKindFilter(param::iterable<hstring> const& remoteSystemKinds);
+    };
+    struct RemoteSystemKinds
+    {
+        RemoteSystemKinds() = delete;
+        [[nodiscard]] static auto Phone();
+        [[nodiscard]] static auto Hub();
+        [[nodiscard]] static auto Holographic();
+        [[nodiscard]] static auto Desktop();
+        [[nodiscard]] static auto Xbox();
+        [[nodiscard]] static auto Iot();
+        [[nodiscard]] static auto Tablet();
+        [[nodiscard]] static auto Laptop();
+    };
+    struct __declspec(empty_bases) RemoteSystemRemovedEventArgs : Windows::System::RemoteSystems::IRemoteSystemRemovedEventArgs
+    {
+        RemoteSystemRemovedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemRemovedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemRemovedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSession : Windows::System::RemoteSystems::IRemoteSystemSession,
+        impl::require<RemoteSystemSession, Windows::Foundation::IClosable>
+    {
+        RemoteSystemSession(std::nullptr_t) noexcept {}
+        RemoteSystemSession(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSession(ptr, take_ownership_from_abi) {}
+        static auto CreateWatcher();
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionAddedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionAddedEventArgs
+    {
+        RemoteSystemSessionAddedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionAddedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionAddedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionController : Windows::System::RemoteSystems::IRemoteSystemSessionController
+    {
+        RemoteSystemSessionController(std::nullptr_t) noexcept {}
+        RemoteSystemSessionController(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionController(ptr, take_ownership_from_abi) {}
+        RemoteSystemSessionController(param::hstring const& displayName);
+        RemoteSystemSessionController(param::hstring const& displayName, Windows::System::RemoteSystems::RemoteSystemSessionOptions const& options);
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionCreationResult : Windows::System::RemoteSystems::IRemoteSystemSessionCreationResult
+    {
+        RemoteSystemSessionCreationResult(std::nullptr_t) noexcept {}
+        RemoteSystemSessionCreationResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionCreationResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionDisconnectedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionDisconnectedEventArgs
+    {
+        RemoteSystemSessionDisconnectedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionDisconnectedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionDisconnectedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionInfo : Windows::System::RemoteSystems::IRemoteSystemSessionInfo
+    {
+        RemoteSystemSessionInfo(std::nullptr_t) noexcept {}
+        RemoteSystemSessionInfo(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionInfo(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionInvitation : Windows::System::RemoteSystems::IRemoteSystemSessionInvitation
+    {
+        RemoteSystemSessionInvitation(std::nullptr_t) noexcept {}
+        RemoteSystemSessionInvitation(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionInvitation(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionInvitationListener : Windows::System::RemoteSystems::IRemoteSystemSessionInvitationListener
+    {
+        RemoteSystemSessionInvitationListener(std::nullptr_t) noexcept {}
+        RemoteSystemSessionInvitationListener(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionInvitationListener(ptr, take_ownership_from_abi) {}
+        RemoteSystemSessionInvitationListener();
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionInvitationReceivedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionInvitationReceivedEventArgs
+    {
+        RemoteSystemSessionInvitationReceivedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionInvitationReceivedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionInvitationReceivedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionJoinRequest : Windows::System::RemoteSystems::IRemoteSystemSessionJoinRequest
+    {
+        RemoteSystemSessionJoinRequest(std::nullptr_t) noexcept {}
+        RemoteSystemSessionJoinRequest(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionJoinRequest(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionJoinRequestedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionJoinRequestedEventArgs
+    {
+        RemoteSystemSessionJoinRequestedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionJoinRequestedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionJoinRequestedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionJoinResult : Windows::System::RemoteSystems::IRemoteSystemSessionJoinResult
+    {
+        RemoteSystemSessionJoinResult(std::nullptr_t) noexcept {}
+        RemoteSystemSessionJoinResult(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionJoinResult(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionMessageChannel : Windows::System::RemoteSystems::IRemoteSystemSessionMessageChannel
+    {
+        RemoteSystemSessionMessageChannel(std::nullptr_t) noexcept {}
+        RemoteSystemSessionMessageChannel(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionMessageChannel(ptr, take_ownership_from_abi) {}
+        RemoteSystemSessionMessageChannel(Windows::System::RemoteSystems::RemoteSystemSession const& session, param::hstring const& channelName);
+        RemoteSystemSessionMessageChannel(Windows::System::RemoteSystems::RemoteSystemSession const& session, param::hstring const& channelName, Windows::System::RemoteSystems::RemoteSystemSessionMessageChannelReliability const& reliability);
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionOptions : Windows::System::RemoteSystems::IRemoteSystemSessionOptions
+    {
+        RemoteSystemSessionOptions(std::nullptr_t) noexcept {}
+        RemoteSystemSessionOptions(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionOptions(ptr, take_ownership_from_abi) {}
+        RemoteSystemSessionOptions();
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionParticipant : Windows::System::RemoteSystems::IRemoteSystemSessionParticipant
+    {
+        RemoteSystemSessionParticipant(std::nullptr_t) noexcept {}
+        RemoteSystemSessionParticipant(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionParticipant(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionParticipantAddedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionParticipantAddedEventArgs
+    {
+        RemoteSystemSessionParticipantAddedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionParticipantAddedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionParticipantAddedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionParticipantRemovedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionParticipantRemovedEventArgs
+    {
+        RemoteSystemSessionParticipantRemovedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionParticipantRemovedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionParticipantRemovedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionParticipantWatcher : Windows::System::RemoteSystems::IRemoteSystemSessionParticipantWatcher
+    {
+        RemoteSystemSessionParticipantWatcher(std::nullptr_t) noexcept {}
+        RemoteSystemSessionParticipantWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionParticipantWatcher(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionRemovedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionRemovedEventArgs
+    {
+        RemoteSystemSessionRemovedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionRemovedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionRemovedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionUpdatedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionUpdatedEventArgs
+    {
+        RemoteSystemSessionUpdatedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionUpdatedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionUpdatedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionValueSetReceivedEventArgs : Windows::System::RemoteSystems::IRemoteSystemSessionValueSetReceivedEventArgs
+    {
+        RemoteSystemSessionValueSetReceivedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemSessionValueSetReceivedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionValueSetReceivedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemSessionWatcher : Windows::System::RemoteSystems::IRemoteSystemSessionWatcher
+    {
+        RemoteSystemSessionWatcher(std::nullptr_t) noexcept {}
+        RemoteSystemSessionWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemSessionWatcher(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemStatusTypeFilter : Windows::System::RemoteSystems::IRemoteSystemStatusTypeFilter,
+        impl::require<RemoteSystemStatusTypeFilter, Windows::System::RemoteSystems::IRemoteSystemFilter>
+    {
+        RemoteSystemStatusTypeFilter(std::nullptr_t) noexcept {}
+        RemoteSystemStatusTypeFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemStatusTypeFilter(ptr, take_ownership_from_abi) {}
+        RemoteSystemStatusTypeFilter(Windows::System::RemoteSystems::RemoteSystemStatusType const& remoteSystemStatusType);
+    };
+    struct __declspec(empty_bases) RemoteSystemUpdatedEventArgs : Windows::System::RemoteSystems::IRemoteSystemUpdatedEventArgs
+    {
+        RemoteSystemUpdatedEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemUpdatedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemUpdatedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemWatcher : Windows::System::RemoteSystems::IRemoteSystemWatcher,
+        impl::require<RemoteSystemWatcher, Windows::System::RemoteSystems::IRemoteSystemWatcher2, Windows::System::RemoteSystems::IRemoteSystemWatcher3>
+    {
+        RemoteSystemWatcher(std::nullptr_t) noexcept {}
+        RemoteSystemWatcher(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemWatcher(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemWatcherErrorOccurredEventArgs : Windows::System::RemoteSystems::IRemoteSystemWatcherErrorOccurredEventArgs
+    {
+        RemoteSystemWatcherErrorOccurredEventArgs(std::nullptr_t) noexcept {}
+        RemoteSystemWatcherErrorOccurredEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemWatcherErrorOccurredEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) RemoteSystemWebAccountFilter : Windows::System::RemoteSystems::IRemoteSystemWebAccountFilter,
+        impl::require<RemoteSystemWebAccountFilter, Windows::System::RemoteSystems::IRemoteSystemFilter>
+    {
+        RemoteSystemWebAccountFilter(std::nullptr_t) noexcept {}
+        RemoteSystemWebAccountFilter(void* ptr, take_ownership_from_abi_t) noexcept : Windows::System::RemoteSystems::IRemoteSystemWebAccountFilter(ptr, take_ownership_from_abi) {}
+        RemoteSystemWebAccountFilter(Windows::Security::Credentials::WebAccount const& account);
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.UI.0.h

@@ -0,0 +1,563 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_UI_0_H
+#define WINRT_Windows_UI_0_H
+namespace winrt::Windows::UI
+{
+    struct IColorHelper;
+    struct IColorHelperStatics;
+    struct IColorHelperStatics2;
+    struct IColors;
+    struct IColorsStatics;
+    struct IUIContentRoot;
+    struct IUIContext;
+    struct ColorHelper;
+    struct Colors;
+    struct UIContentRoot;
+    struct UIContext;
+    struct Color;
+}
+namespace winrt::impl
+{
+    template <> struct category<Windows::UI::IColorHelper>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::UI::IColorHelperStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::UI::IColorHelperStatics2>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::UI::IColors>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::UI::IColorsStatics>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::UI::IUIContentRoot>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::UI::IUIContext>
+    {
+        using type = interface_category;
+    };
+    template <> struct category<Windows::UI::ColorHelper>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::UI::Colors>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::UI::UIContentRoot>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::UI::UIContext>
+    {
+        using type = class_category;
+    };
+    template <> struct category<Windows::UI::Color>
+    {
+        using type = struct_category<uint8_t, uint8_t, uint8_t, uint8_t>;
+    };
+    template <> struct name<Windows::UI::IColorHelper>
+    {
+        static constexpr auto & value{ L"Windows.UI.IColorHelper" };
+    };
+    template <> struct name<Windows::UI::IColorHelperStatics>
+    {
+        static constexpr auto & value{ L"Windows.UI.IColorHelperStatics" };
+    };
+    template <> struct name<Windows::UI::IColorHelperStatics2>
+    {
+        static constexpr auto & value{ L"Windows.UI.IColorHelperStatics2" };
+    };
+    template <> struct name<Windows::UI::IColors>
+    {
+        static constexpr auto & value{ L"Windows.UI.IColors" };
+    };
+    template <> struct name<Windows::UI::IColorsStatics>
+    {
+        static constexpr auto & value{ L"Windows.UI.IColorsStatics" };
+    };
+    template <> struct name<Windows::UI::IUIContentRoot>
+    {
+        static constexpr auto & value{ L"Windows.UI.IUIContentRoot" };
+    };
+    template <> struct name<Windows::UI::IUIContext>
+    {
+        static constexpr auto & value{ L"Windows.UI.IUIContext" };
+    };
+    template <> struct name<Windows::UI::ColorHelper>
+    {
+        static constexpr auto & value{ L"Windows.UI.ColorHelper" };
+    };
+    template <> struct name<Windows::UI::Colors>
+    {
+        static constexpr auto & value{ L"Windows.UI.Colors" };
+    };
+    template <> struct name<Windows::UI::UIContentRoot>
+    {
+        static constexpr auto & value{ L"Windows.UI.UIContentRoot" };
+    };
+    template <> struct name<Windows::UI::UIContext>
+    {
+        static constexpr auto & value{ L"Windows.UI.UIContext" };
+    };
+    template <> struct name<Windows::UI::Color>
+    {
+        static constexpr auto & value{ L"Windows.UI.Color" };
+    };
+    template <> struct guid_storage<Windows::UI::IColorHelper>
+    {
+        static constexpr guid value{ 0x193CFBE7,0x65C7,0x4540,{ 0xAD,0x08,0x62,0x83,0xBA,0x76,0x87,0x9A } };
+    };
+    template <> struct guid_storage<Windows::UI::IColorHelperStatics>
+    {
+        static constexpr guid value{ 0x8504DBEA,0xFB6A,0x4144,{ 0xA6,0xC2,0x33,0x49,0x9C,0x92,0x84,0xF5 } };
+    };
+    template <> struct guid_storage<Windows::UI::IColorHelperStatics2>
+    {
+        static constexpr guid value{ 0x24D9AF02,0x6EB0,0x4B94,{ 0x85,0x5C,0xFC,0xF0,0x81,0x8D,0x9A,0x16 } };
+    };
+    template <> struct guid_storage<Windows::UI::IColors>
+    {
+        static constexpr guid value{ 0x9B8C9326,0x4CA6,0x4CE5,{ 0x89,0x94,0x9E,0xFF,0x65,0xCA,0xBD,0xCC } };
+    };
+    template <> struct guid_storage<Windows::UI::IColorsStatics>
+    {
+        static constexpr guid value{ 0xCFF52E04,0xCCA6,0x4614,{ 0xA1,0x7E,0x75,0x49,0x10,0xC8,0x4A,0x99 } };
+    };
+    template <> struct guid_storage<Windows::UI::IUIContentRoot>
+    {
+        static constexpr guid value{ 0x1DFCBAC6,0xB36B,0x5CB9,{ 0x9B,0xC5,0x2B,0x7A,0x0E,0xDD,0xC3,0x78 } };
+    };
+    template <> struct guid_storage<Windows::UI::IUIContext>
+    {
+        static constexpr guid value{ 0xBB5CFACD,0x5BD8,0x59D0,{ 0xA5,0x9E,0x1C,0x17,0xA4,0xD6,0xD2,0x43 } };
+    };
+    template <> struct default_interface<Windows::UI::ColorHelper>
+    {
+        using type = Windows::UI::IColorHelper;
+    };
+    template <> struct default_interface<Windows::UI::Colors>
+    {
+        using type = Windows::UI::IColors;
+    };
+    template <> struct default_interface<Windows::UI::UIContentRoot>
+    {
+        using type = Windows::UI::IUIContentRoot;
+    };
+    template <> struct default_interface<Windows::UI::UIContext>
+    {
+        using type = Windows::UI::IUIContext;
+    };
+    template <> struct abi<Windows::UI::IColorHelper>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+        };
+    };
+    template <> struct abi<Windows::UI::IColorHelperStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall FromArgb(uint8_t, uint8_t, uint8_t, uint8_t, struct struct_Windows_UI_Color*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::UI::IColorHelperStatics2>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall ToDisplayName(struct struct_Windows_UI_Color, void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::UI::IColors>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+        };
+    };
+    template <> struct abi<Windows::UI::IColorsStatics>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_AliceBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_AntiqueWhite(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Aqua(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Aquamarine(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Azure(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Beige(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Bisque(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Black(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_BlanchedAlmond(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Blue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_BlueViolet(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Brown(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_BurlyWood(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_CadetBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Chartreuse(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Chocolate(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Coral(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_CornflowerBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Cornsilk(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Crimson(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Cyan(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkCyan(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkGoldenrod(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkGray(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkKhaki(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkMagenta(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkOliveGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkOrange(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkOrchid(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkRed(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkSalmon(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkSeaGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkSlateBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkSlateGray(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkTurquoise(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DarkViolet(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DeepPink(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DeepSkyBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DimGray(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_DodgerBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Firebrick(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_FloralWhite(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_ForestGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Fuchsia(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Gainsboro(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_GhostWhite(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Gold(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Goldenrod(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Gray(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Green(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_GreenYellow(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Honeydew(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_HotPink(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_IndianRed(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Indigo(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Ivory(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Khaki(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Lavender(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LavenderBlush(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LawnGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LemonChiffon(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightCoral(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightCyan(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightGoldenrodYellow(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightGray(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightPink(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightSalmon(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightSeaGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightSkyBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightSlateGray(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightSteelBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LightYellow(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Lime(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_LimeGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Linen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Magenta(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Maroon(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumAquamarine(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumOrchid(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumPurple(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumSeaGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumSlateBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumSpringGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumTurquoise(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MediumVioletRed(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MidnightBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MintCream(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_MistyRose(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Moccasin(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_NavajoWhite(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Navy(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_OldLace(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Olive(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_OliveDrab(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Orange(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_OrangeRed(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Orchid(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_PaleGoldenrod(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_PaleGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_PaleTurquoise(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_PaleVioletRed(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_PapayaWhip(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_PeachPuff(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Peru(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Pink(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Plum(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_PowderBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Purple(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Red(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_RosyBrown(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_RoyalBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SaddleBrown(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Salmon(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SandyBrown(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SeaGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SeaShell(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Sienna(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Silver(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SkyBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SlateBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SlateGray(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Snow(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SpringGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_SteelBlue(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Tan(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Teal(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Thistle(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Tomato(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Transparent(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Turquoise(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Violet(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Wheat(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_White(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_WhiteSmoke(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_Yellow(struct struct_Windows_UI_Color*) noexcept = 0;
+            virtual int32_t __stdcall get_YellowGreen(struct struct_Windows_UI_Color*) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::UI::IUIContentRoot>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+            virtual int32_t __stdcall get_UIContext(void**) noexcept = 0;
+        };
+    };
+    template <> struct abi<Windows::UI::IUIContext>
+    {
+        struct __declspec(novtable) type : inspectable_abi
+        {
+        };
+    };
+    template <typename D>
+    struct consume_Windows_UI_IColorHelper
+    {
+    };
+    template <> struct consume<Windows::UI::IColorHelper>
+    {
+        template <typename D> using type = consume_Windows_UI_IColorHelper<D>;
+    };
+    template <typename D>
+    struct consume_Windows_UI_IColorHelperStatics
+    {
+        auto FromArgb(uint8_t a, uint8_t r, uint8_t g, uint8_t b) const;
+    };
+    template <> struct consume<Windows::UI::IColorHelperStatics>
+    {
+        template <typename D> using type = consume_Windows_UI_IColorHelperStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_UI_IColorHelperStatics2
+    {
+        auto ToDisplayName(Windows::UI::Color const& color) const;
+    };
+    template <> struct consume<Windows::UI::IColorHelperStatics2>
+    {
+        template <typename D> using type = consume_Windows_UI_IColorHelperStatics2<D>;
+    };
+    template <typename D>
+    struct consume_Windows_UI_IColors
+    {
+    };
+    template <> struct consume<Windows::UI::IColors>
+    {
+        template <typename D> using type = consume_Windows_UI_IColors<D>;
+    };
+    template <typename D>
+    struct consume_Windows_UI_IColorsStatics
+    {
+        [[nodiscard]] auto AliceBlue() const;
+        [[nodiscard]] auto AntiqueWhite() const;
+        [[nodiscard]] auto Aqua() const;
+        [[nodiscard]] auto Aquamarine() const;
+        [[nodiscard]] auto Azure() const;
+        [[nodiscard]] auto Beige() const;
+        [[nodiscard]] auto Bisque() const;
+        [[nodiscard]] auto Black() const;
+        [[nodiscard]] auto BlanchedAlmond() const;
+        [[nodiscard]] auto Blue() const;
+        [[nodiscard]] auto BlueViolet() const;
+        [[nodiscard]] auto Brown() const;
+        [[nodiscard]] auto BurlyWood() const;
+        [[nodiscard]] auto CadetBlue() const;
+        [[nodiscard]] auto Chartreuse() const;
+        [[nodiscard]] auto Chocolate() const;
+        [[nodiscard]] auto Coral() const;
+        [[nodiscard]] auto CornflowerBlue() const;
+        [[nodiscard]] auto Cornsilk() const;
+        [[nodiscard]] auto Crimson() const;
+        [[nodiscard]] auto Cyan() const;
+        [[nodiscard]] auto DarkBlue() const;
+        [[nodiscard]] auto DarkCyan() const;
+        [[nodiscard]] auto DarkGoldenrod() const;
+        [[nodiscard]] auto DarkGray() const;
+        [[nodiscard]] auto DarkGreen() const;
+        [[nodiscard]] auto DarkKhaki() const;
+        [[nodiscard]] auto DarkMagenta() const;
+        [[nodiscard]] auto DarkOliveGreen() const;
+        [[nodiscard]] auto DarkOrange() const;
+        [[nodiscard]] auto DarkOrchid() const;
+        [[nodiscard]] auto DarkRed() const;
+        [[nodiscard]] auto DarkSalmon() const;
+        [[nodiscard]] auto DarkSeaGreen() const;
+        [[nodiscard]] auto DarkSlateBlue() const;
+        [[nodiscard]] auto DarkSlateGray() const;
+        [[nodiscard]] auto DarkTurquoise() const;
+        [[nodiscard]] auto DarkViolet() const;
+        [[nodiscard]] auto DeepPink() const;
+        [[nodiscard]] auto DeepSkyBlue() const;
+        [[nodiscard]] auto DimGray() const;
+        [[nodiscard]] auto DodgerBlue() const;
+        [[nodiscard]] auto Firebrick() const;
+        [[nodiscard]] auto FloralWhite() const;
+        [[nodiscard]] auto ForestGreen() const;
+        [[nodiscard]] auto Fuchsia() const;
+        [[nodiscard]] auto Gainsboro() const;
+        [[nodiscard]] auto GhostWhite() const;
+        [[nodiscard]] auto Gold() const;
+        [[nodiscard]] auto Goldenrod() const;
+        [[nodiscard]] auto Gray() const;
+        [[nodiscard]] auto Green() const;
+        [[nodiscard]] auto GreenYellow() const;
+        [[nodiscard]] auto Honeydew() const;
+        [[nodiscard]] auto HotPink() const;
+        [[nodiscard]] auto IndianRed() const;
+        [[nodiscard]] auto Indigo() const;
+        [[nodiscard]] auto Ivory() const;
+        [[nodiscard]] auto Khaki() const;
+        [[nodiscard]] auto Lavender() const;
+        [[nodiscard]] auto LavenderBlush() const;
+        [[nodiscard]] auto LawnGreen() const;
+        [[nodiscard]] auto LemonChiffon() const;
+        [[nodiscard]] auto LightBlue() const;
+        [[nodiscard]] auto LightCoral() const;
+        [[nodiscard]] auto LightCyan() const;
+        [[nodiscard]] auto LightGoldenrodYellow() const;
+        [[nodiscard]] auto LightGreen() const;
+        [[nodiscard]] auto LightGray() const;
+        [[nodiscard]] auto LightPink() const;
+        [[nodiscard]] auto LightSalmon() const;
+        [[nodiscard]] auto LightSeaGreen() const;
+        [[nodiscard]] auto LightSkyBlue() const;
+        [[nodiscard]] auto LightSlateGray() const;
+        [[nodiscard]] auto LightSteelBlue() const;
+        [[nodiscard]] auto LightYellow() const;
+        [[nodiscard]] auto Lime() const;
+        [[nodiscard]] auto LimeGreen() const;
+        [[nodiscard]] auto Linen() const;
+        [[nodiscard]] auto Magenta() const;
+        [[nodiscard]] auto Maroon() const;
+        [[nodiscard]] auto MediumAquamarine() const;
+        [[nodiscard]] auto MediumBlue() const;
+        [[nodiscard]] auto MediumOrchid() const;
+        [[nodiscard]] auto MediumPurple() const;
+        [[nodiscard]] auto MediumSeaGreen() const;
+        [[nodiscard]] auto MediumSlateBlue() const;
+        [[nodiscard]] auto MediumSpringGreen() const;
+        [[nodiscard]] auto MediumTurquoise() const;
+        [[nodiscard]] auto MediumVioletRed() const;
+        [[nodiscard]] auto MidnightBlue() const;
+        [[nodiscard]] auto MintCream() const;
+        [[nodiscard]] auto MistyRose() const;
+        [[nodiscard]] auto Moccasin() const;
+        [[nodiscard]] auto NavajoWhite() const;
+        [[nodiscard]] auto Navy() const;
+        [[nodiscard]] auto OldLace() const;
+        [[nodiscard]] auto Olive() const;
+        [[nodiscard]] auto OliveDrab() const;
+        [[nodiscard]] auto Orange() const;
+        [[nodiscard]] auto OrangeRed() const;
+        [[nodiscard]] auto Orchid() const;
+        [[nodiscard]] auto PaleGoldenrod() const;
+        [[nodiscard]] auto PaleGreen() const;
+        [[nodiscard]] auto PaleTurquoise() const;
+        [[nodiscard]] auto PaleVioletRed() const;
+        [[nodiscard]] auto PapayaWhip() const;
+        [[nodiscard]] auto PeachPuff() const;
+        [[nodiscard]] auto Peru() const;
+        [[nodiscard]] auto Pink() const;
+        [[nodiscard]] auto Plum() const;
+        [[nodiscard]] auto PowderBlue() const;
+        [[nodiscard]] auto Purple() const;
+        [[nodiscard]] auto Red() const;
+        [[nodiscard]] auto RosyBrown() const;
+        [[nodiscard]] auto RoyalBlue() const;
+        [[nodiscard]] auto SaddleBrown() const;
+        [[nodiscard]] auto Salmon() const;
+        [[nodiscard]] auto SandyBrown() const;
+        [[nodiscard]] auto SeaGreen() const;
+        [[nodiscard]] auto SeaShell() const;
+        [[nodiscard]] auto Sienna() const;
+        [[nodiscard]] auto Silver() const;
+        [[nodiscard]] auto SkyBlue() const;
+        [[nodiscard]] auto SlateBlue() const;
+        [[nodiscard]] auto SlateGray() const;
+        [[nodiscard]] auto Snow() const;
+        [[nodiscard]] auto SpringGreen() const;
+        [[nodiscard]] auto SteelBlue() const;
+        [[nodiscard]] auto Tan() const;
+        [[nodiscard]] auto Teal() const;
+        [[nodiscard]] auto Thistle() const;
+        [[nodiscard]] auto Tomato() const;
+        [[nodiscard]] auto Transparent() const;
+        [[nodiscard]] auto Turquoise() const;
+        [[nodiscard]] auto Violet() const;
+        [[nodiscard]] auto Wheat() const;
+        [[nodiscard]] auto White() const;
+        [[nodiscard]] auto WhiteSmoke() const;
+        [[nodiscard]] auto Yellow() const;
+        [[nodiscard]] auto YellowGreen() const;
+    };
+    template <> struct consume<Windows::UI::IColorsStatics>
+    {
+        template <typename D> using type = consume_Windows_UI_IColorsStatics<D>;
+    };
+    template <typename D>
+    struct consume_Windows_UI_IUIContentRoot
+    {
+        [[nodiscard]] auto UIContext() const;
+    };
+    template <> struct consume<Windows::UI::IUIContentRoot>
+    {
+        template <typename D> using type = consume_Windows_UI_IUIContentRoot<D>;
+    };
+    template <typename D>
+    struct consume_Windows_UI_IUIContext
+    {
+    };
+    template <> struct consume<Windows::UI::IUIContext>
+    {
+        template <typename D> using type = consume_Windows_UI_IUIContext<D>;
+    };
+    struct struct_Windows_UI_Color
+    {
+        uint8_t A;
+        uint8_t R;
+        uint8_t G;
+        uint8_t B;
+    };
+    template <> struct abi<Windows::UI::Color>
+    {
+        using type = struct_Windows_UI_Color;
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.UI.1.h

@@ -0,0 +1,61 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_UI_1_H
+#define WINRT_Windows_UI_1_H
+#include "Windows.UI.0.h"
+namespace winrt::Windows::UI
+{
+    struct __declspec(empty_bases) IColorHelper :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IColorHelper>
+    {
+        IColorHelper(std::nullptr_t = nullptr) noexcept {}
+        IColorHelper(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IColorHelperStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IColorHelperStatics>
+    {
+        IColorHelperStatics(std::nullptr_t = nullptr) noexcept {}
+        IColorHelperStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IColorHelperStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IColorHelperStatics2>
+    {
+        IColorHelperStatics2(std::nullptr_t = nullptr) noexcept {}
+        IColorHelperStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IColors :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IColors>
+    {
+        IColors(std::nullptr_t = nullptr) noexcept {}
+        IColors(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IColorsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IColorsStatics>
+    {
+        IColorsStatics(std::nullptr_t = nullptr) noexcept {}
+        IColorsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUIContentRoot :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUIContentRoot>
+    {
+        IUIContentRoot(std::nullptr_t = nullptr) noexcept {}
+        IUIContentRoot(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUIContext :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUIContext>
+    {
+        IUIContext(std::nullptr_t = nullptr) noexcept {}
+        IUIContext(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.UI.2.h

@@ -0,0 +1,190 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_UI_2_H
+#define WINRT_Windows_UI_2_H
+#include "Windows.UI.1.h"
+namespace winrt::Windows::UI
+{
+    struct Color
+    {
+        uint8_t A;
+        uint8_t R;
+        uint8_t G;
+        uint8_t B;
+    };
+    inline bool operator==(Color const& left, Color const& right) noexcept
+    {
+        return left.A == right.A && left.R == right.R && left.G == right.G && left.B == right.B;
+    }
+    inline bool operator!=(Color const& left, Color const& right) noexcept
+    {
+        return !(left == right);
+    }
+    struct __declspec(empty_bases) ColorHelper : Windows::UI::IColorHelper
+    {
+        ColorHelper(std::nullptr_t) noexcept {}
+        ColorHelper(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::IColorHelper(ptr, take_ownership_from_abi) {}
+        static auto FromArgb(uint8_t a, uint8_t r, uint8_t g, uint8_t b);
+        static auto ToDisplayName(Windows::UI::Color const& color);
+    };
+    struct __declspec(empty_bases) Colors : Windows::UI::IColors
+    {
+        Colors(std::nullptr_t) noexcept {}
+        Colors(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::IColors(ptr, take_ownership_from_abi) {}
+        [[nodiscard]] static auto AliceBlue();
+        [[nodiscard]] static auto AntiqueWhite();
+        [[nodiscard]] static auto Aqua();
+        [[nodiscard]] static auto Aquamarine();
+        [[nodiscard]] static auto Azure();
+        [[nodiscard]] static auto Beige();
+        [[nodiscard]] static auto Bisque();
+        [[nodiscard]] static auto Black();
+        [[nodiscard]] static auto BlanchedAlmond();
+        [[nodiscard]] static auto Blue();
+        [[nodiscard]] static auto BlueViolet();
+        [[nodiscard]] static auto Brown();
+        [[nodiscard]] static auto BurlyWood();
+        [[nodiscard]] static auto CadetBlue();
+        [[nodiscard]] static auto Chartreuse();
+        [[nodiscard]] static auto Chocolate();
+        [[nodiscard]] static auto Coral();
+        [[nodiscard]] static auto CornflowerBlue();
+        [[nodiscard]] static auto Cornsilk();
+        [[nodiscard]] static auto Crimson();
+        [[nodiscard]] static auto Cyan();
+        [[nodiscard]] static auto DarkBlue();
+        [[nodiscard]] static auto DarkCyan();
+        [[nodiscard]] static auto DarkGoldenrod();
+        [[nodiscard]] static auto DarkGray();
+        [[nodiscard]] static auto DarkGreen();
+        [[nodiscard]] static auto DarkKhaki();
+        [[nodiscard]] static auto DarkMagenta();
+        [[nodiscard]] static auto DarkOliveGreen();
+        [[nodiscard]] static auto DarkOrange();
+        [[nodiscard]] static auto DarkOrchid();
+        [[nodiscard]] static auto DarkRed();
+        [[nodiscard]] static auto DarkSalmon();
+        [[nodiscard]] static auto DarkSeaGreen();
+        [[nodiscard]] static auto DarkSlateBlue();
+        [[nodiscard]] static auto DarkSlateGray();
+        [[nodiscard]] static auto DarkTurquoise();
+        [[nodiscard]] static auto DarkViolet();
+        [[nodiscard]] static auto DeepPink();
+        [[nodiscard]] static auto DeepSkyBlue();
+        [[nodiscard]] static auto DimGray();
+        [[nodiscard]] static auto DodgerBlue();
+        [[nodiscard]] static auto Firebrick();
+        [[nodiscard]] static auto FloralWhite();
+        [[nodiscard]] static auto ForestGreen();
+        [[nodiscard]] static auto Fuchsia();
+        [[nodiscard]] static auto Gainsboro();
+        [[nodiscard]] static auto GhostWhite();
+        [[nodiscard]] static auto Gold();
+        [[nodiscard]] static auto Goldenrod();
+        [[nodiscard]] static auto Gray();
+        [[nodiscard]] static auto Green();
+        [[nodiscard]] static auto GreenYellow();
+        [[nodiscard]] static auto Honeydew();
+        [[nodiscard]] static auto HotPink();
+        [[nodiscard]] static auto IndianRed();
+        [[nodiscard]] static auto Indigo();
+        [[nodiscard]] static auto Ivory();
+        [[nodiscard]] static auto Khaki();
+        [[nodiscard]] static auto Lavender();
+        [[nodiscard]] static auto LavenderBlush();
+        [[nodiscard]] static auto LawnGreen();
+        [[nodiscard]] static auto LemonChiffon();
+        [[nodiscard]] static auto LightBlue();
+        [[nodiscard]] static auto LightCoral();
+        [[nodiscard]] static auto LightCyan();
+        [[nodiscard]] static auto LightGoldenrodYellow();
+        [[nodiscard]] static auto LightGreen();
+        [[nodiscard]] static auto LightGray();
+        [[nodiscard]] static auto LightPink();
+        [[nodiscard]] static auto LightSalmon();
+        [[nodiscard]] static auto LightSeaGreen();
+        [[nodiscard]] static auto LightSkyBlue();
+        [[nodiscard]] static auto LightSlateGray();
+        [[nodiscard]] static auto LightSteelBlue();
+        [[nodiscard]] static auto LightYellow();
+        [[nodiscard]] static auto Lime();
+        [[nodiscard]] static auto LimeGreen();
+        [[nodiscard]] static auto Linen();
+        [[nodiscard]] static auto Magenta();
+        [[nodiscard]] static auto Maroon();
+        [[nodiscard]] static auto MediumAquamarine();
+        [[nodiscard]] static auto MediumBlue();
+        [[nodiscard]] static auto MediumOrchid();
+        [[nodiscard]] static auto MediumPurple();
+        [[nodiscard]] static auto MediumSeaGreen();
+        [[nodiscard]] static auto MediumSlateBlue();
+        [[nodiscard]] static auto MediumSpringGreen();
+        [[nodiscard]] static auto MediumTurquoise();
+        [[nodiscard]] static auto MediumVioletRed();
+        [[nodiscard]] static auto MidnightBlue();
+        [[nodiscard]] static auto MintCream();
+        [[nodiscard]] static auto MistyRose();
+        [[nodiscard]] static auto Moccasin();
+        [[nodiscard]] static auto NavajoWhite();
+        [[nodiscard]] static auto Navy();
+        [[nodiscard]] static auto OldLace();
+        [[nodiscard]] static auto Olive();
+        [[nodiscard]] static auto OliveDrab();
+        [[nodiscard]] static auto Orange();
+        [[nodiscard]] static auto OrangeRed();
+        [[nodiscard]] static auto Orchid();
+        [[nodiscard]] static auto PaleGoldenrod();
+        [[nodiscard]] static auto PaleGreen();
+        [[nodiscard]] static auto PaleTurquoise();
+        [[nodiscard]] static auto PaleVioletRed();
+        [[nodiscard]] static auto PapayaWhip();
+        [[nodiscard]] static auto PeachPuff();
+        [[nodiscard]] static auto Peru();
+        [[nodiscard]] static auto Pink();
+        [[nodiscard]] static auto Plum();
+        [[nodiscard]] static auto PowderBlue();
+        [[nodiscard]] static auto Purple();
+        [[nodiscard]] static auto Red();
+        [[nodiscard]] static auto RosyBrown();
+        [[nodiscard]] static auto RoyalBlue();
+        [[nodiscard]] static auto SaddleBrown();
+        [[nodiscard]] static auto Salmon();
+        [[nodiscard]] static auto SandyBrown();
+        [[nodiscard]] static auto SeaGreen();
+        [[nodiscard]] static auto SeaShell();
+        [[nodiscard]] static auto Sienna();
+        [[nodiscard]] static auto Silver();
+        [[nodiscard]] static auto SkyBlue();
+        [[nodiscard]] static auto SlateBlue();
+        [[nodiscard]] static auto SlateGray();
+        [[nodiscard]] static auto Snow();
+        [[nodiscard]] static auto SpringGreen();
+        [[nodiscard]] static auto SteelBlue();
+        [[nodiscard]] static auto Tan();
+        [[nodiscard]] static auto Teal();
+        [[nodiscard]] static auto Thistle();
+        [[nodiscard]] static auto Tomato();
+        [[nodiscard]] static auto Transparent();
+        [[nodiscard]] static auto Turquoise();
+        [[nodiscard]] static auto Violet();
+        [[nodiscard]] static auto Wheat();
+        [[nodiscard]] static auto White();
+        [[nodiscard]] static auto WhiteSmoke();
+        [[nodiscard]] static auto Yellow();
+        [[nodiscard]] static auto YellowGreen();
+    };
+    struct __declspec(empty_bases) UIContentRoot : Windows::UI::IUIContentRoot
+    {
+        UIContentRoot(std::nullptr_t) noexcept {}
+        UIContentRoot(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::IUIContentRoot(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) UIContext : Windows::UI::IUIContext
+    {
+        UIContext(std::nullptr_t) noexcept {}
+        UIContext(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::IUIContext(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.UI.Notifications.1.h

@@ -0,0 +1,467 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_UI_Notifications_1_H
+#define WINRT_Windows_UI_Notifications_1_H
+#include "Windows.UI.Notifications.0.h"
+namespace winrt::Windows::UI::Notifications
+{
+    struct __declspec(empty_bases) IAdaptiveNotificationContent :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAdaptiveNotificationContent>
+    {
+        IAdaptiveNotificationContent(std::nullptr_t = nullptr) noexcept {}
+        IAdaptiveNotificationContent(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IAdaptiveNotificationText :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IAdaptiveNotificationText>
+    {
+        IAdaptiveNotificationText(std::nullptr_t = nullptr) noexcept {}
+        IAdaptiveNotificationText(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBadgeNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBadgeNotification>
+    {
+        IBadgeNotification(std::nullptr_t = nullptr) noexcept {}
+        IBadgeNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBadgeNotificationFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBadgeNotificationFactory>
+    {
+        IBadgeNotificationFactory(std::nullptr_t = nullptr) noexcept {}
+        IBadgeNotificationFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBadgeUpdateManagerForUser :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBadgeUpdateManagerForUser>
+    {
+        IBadgeUpdateManagerForUser(std::nullptr_t = nullptr) noexcept {}
+        IBadgeUpdateManagerForUser(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBadgeUpdateManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBadgeUpdateManagerStatics>
+    {
+        IBadgeUpdateManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        IBadgeUpdateManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBadgeUpdateManagerStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBadgeUpdateManagerStatics2>
+    {
+        IBadgeUpdateManagerStatics2(std::nullptr_t = nullptr) noexcept {}
+        IBadgeUpdateManagerStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IBadgeUpdater :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IBadgeUpdater>
+    {
+        IBadgeUpdater(std::nullptr_t = nullptr) noexcept {}
+        IBadgeUpdater(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownAdaptiveNotificationHintsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownAdaptiveNotificationHintsStatics>
+    {
+        IKnownAdaptiveNotificationHintsStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownAdaptiveNotificationHintsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownAdaptiveNotificationTextStylesStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownAdaptiveNotificationTextStylesStatics>
+    {
+        IKnownAdaptiveNotificationTextStylesStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownAdaptiveNotificationTextStylesStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IKnownNotificationBindingsStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IKnownNotificationBindingsStatics>
+    {
+        IKnownNotificationBindingsStatics(std::nullptr_t = nullptr) noexcept {}
+        IKnownNotificationBindingsStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) INotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<INotification>
+    {
+        INotification(std::nullptr_t = nullptr) noexcept {}
+        INotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) INotificationBinding :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<INotificationBinding>
+    {
+        INotificationBinding(std::nullptr_t = nullptr) noexcept {}
+        INotificationBinding(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) INotificationData :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<INotificationData>
+    {
+        INotificationData(std::nullptr_t = nullptr) noexcept {}
+        INotificationData(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) INotificationDataFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<INotificationDataFactory>
+    {
+        INotificationDataFactory(std::nullptr_t = nullptr) noexcept {}
+        INotificationDataFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) INotificationVisual :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<INotificationVisual>
+    {
+        INotificationVisual(std::nullptr_t = nullptr) noexcept {}
+        INotificationVisual(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledTileNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledTileNotification>
+    {
+        IScheduledTileNotification(std::nullptr_t = nullptr) noexcept {}
+        IScheduledTileNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledTileNotificationFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledTileNotificationFactory>
+    {
+        IScheduledTileNotificationFactory(std::nullptr_t = nullptr) noexcept {}
+        IScheduledTileNotificationFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledToastNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledToastNotification>
+    {
+        IScheduledToastNotification(std::nullptr_t = nullptr) noexcept {}
+        IScheduledToastNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledToastNotification2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledToastNotification2>
+    {
+        IScheduledToastNotification2(std::nullptr_t = nullptr) noexcept {}
+        IScheduledToastNotification2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledToastNotification3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledToastNotification3>
+    {
+        IScheduledToastNotification3(std::nullptr_t = nullptr) noexcept {}
+        IScheduledToastNotification3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledToastNotification4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledToastNotification4>
+    {
+        IScheduledToastNotification4(std::nullptr_t = nullptr) noexcept {}
+        IScheduledToastNotification4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledToastNotificationFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledToastNotificationFactory>
+    {
+        IScheduledToastNotificationFactory(std::nullptr_t = nullptr) noexcept {}
+        IScheduledToastNotificationFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IScheduledToastNotificationShowingEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IScheduledToastNotificationShowingEventArgs>
+    {
+        IScheduledToastNotificationShowingEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IScheduledToastNotificationShowingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IShownTileNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IShownTileNotification>
+    {
+        IShownTileNotification(std::nullptr_t = nullptr) noexcept {}
+        IShownTileNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileFlyoutNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileFlyoutNotification>
+    {
+        ITileFlyoutNotification(std::nullptr_t = nullptr) noexcept {}
+        ITileFlyoutNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileFlyoutNotificationFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileFlyoutNotificationFactory>
+    {
+        ITileFlyoutNotificationFactory(std::nullptr_t = nullptr) noexcept {}
+        ITileFlyoutNotificationFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileFlyoutUpdateManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileFlyoutUpdateManagerStatics>
+    {
+        ITileFlyoutUpdateManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        ITileFlyoutUpdateManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileFlyoutUpdater :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileFlyoutUpdater>
+    {
+        ITileFlyoutUpdater(std::nullptr_t = nullptr) noexcept {}
+        ITileFlyoutUpdater(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileNotification>
+    {
+        ITileNotification(std::nullptr_t = nullptr) noexcept {}
+        ITileNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileNotificationFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileNotificationFactory>
+    {
+        ITileNotificationFactory(std::nullptr_t = nullptr) noexcept {}
+        ITileNotificationFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileUpdateManagerForUser :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileUpdateManagerForUser>
+    {
+        ITileUpdateManagerForUser(std::nullptr_t = nullptr) noexcept {}
+        ITileUpdateManagerForUser(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileUpdateManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileUpdateManagerStatics>
+    {
+        ITileUpdateManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        ITileUpdateManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileUpdateManagerStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileUpdateManagerStatics2>
+    {
+        ITileUpdateManagerStatics2(std::nullptr_t = nullptr) noexcept {}
+        ITileUpdateManagerStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileUpdater :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileUpdater>
+    {
+        ITileUpdater(std::nullptr_t = nullptr) noexcept {}
+        ITileUpdater(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ITileUpdater2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<ITileUpdater2>
+    {
+        ITileUpdater2(std::nullptr_t = nullptr) noexcept {}
+        ITileUpdater2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastActivatedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastActivatedEventArgs>
+    {
+        IToastActivatedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IToastActivatedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastActivatedEventArgs2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastActivatedEventArgs2>
+    {
+        IToastActivatedEventArgs2(std::nullptr_t = nullptr) noexcept {}
+        IToastActivatedEventArgs2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastCollection :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastCollection>
+    {
+        IToastCollection(std::nullptr_t = nullptr) noexcept {}
+        IToastCollection(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastCollectionFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastCollectionFactory>
+    {
+        IToastCollectionFactory(std::nullptr_t = nullptr) noexcept {}
+        IToastCollectionFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastCollectionManager :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastCollectionManager>
+    {
+        IToastCollectionManager(std::nullptr_t = nullptr) noexcept {}
+        IToastCollectionManager(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastDismissedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastDismissedEventArgs>
+    {
+        IToastDismissedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IToastDismissedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastFailedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastFailedEventArgs>
+    {
+        IToastFailedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IToastFailedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotification>
+    {
+        IToastNotification(std::nullptr_t = nullptr) noexcept {}
+        IToastNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotification2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotification2>
+    {
+        IToastNotification2(std::nullptr_t = nullptr) noexcept {}
+        IToastNotification2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotification3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotification3>
+    {
+        IToastNotification3(std::nullptr_t = nullptr) noexcept {}
+        IToastNotification3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotification4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotification4>
+    {
+        IToastNotification4(std::nullptr_t = nullptr) noexcept {}
+        IToastNotification4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotification6 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotification6>
+    {
+        IToastNotification6(std::nullptr_t = nullptr) noexcept {}
+        IToastNotification6(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationActionTriggerDetail :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationActionTriggerDetail>
+    {
+        IToastNotificationActionTriggerDetail(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationActionTriggerDetail(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationFactory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationFactory>
+    {
+        IToastNotificationFactory(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationFactory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationHistory :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationHistory>
+    {
+        IToastNotificationHistory(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationHistory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationHistory2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationHistory2>
+    {
+        IToastNotificationHistory2(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationHistory2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationHistoryChangedTriggerDetail :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationHistoryChangedTriggerDetail>
+    {
+        IToastNotificationHistoryChangedTriggerDetail(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationHistoryChangedTriggerDetail(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationHistoryChangedTriggerDetail2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationHistoryChangedTriggerDetail2>
+    {
+        IToastNotificationHistoryChangedTriggerDetail2(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationHistoryChangedTriggerDetail2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationManagerForUser :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationManagerForUser>
+    {
+        IToastNotificationManagerForUser(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationManagerForUser(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationManagerForUser2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationManagerForUser2>
+    {
+        IToastNotificationManagerForUser2(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationManagerForUser2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationManagerStatics :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationManagerStatics>
+    {
+        IToastNotificationManagerStatics(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationManagerStatics(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationManagerStatics2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationManagerStatics2>
+    {
+        IToastNotificationManagerStatics2(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationManagerStatics2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationManagerStatics4 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationManagerStatics4>
+    {
+        IToastNotificationManagerStatics4(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationManagerStatics4(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotificationManagerStatics5 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotificationManagerStatics5>
+    {
+        IToastNotificationManagerStatics5(std::nullptr_t = nullptr) noexcept {}
+        IToastNotificationManagerStatics5(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotifier :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotifier>
+    {
+        IToastNotifier(std::nullptr_t = nullptr) noexcept {}
+        IToastNotifier(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotifier2 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotifier2>
+    {
+        IToastNotifier2(std::nullptr_t = nullptr) noexcept {}
+        IToastNotifier2(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IToastNotifier3 :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IToastNotifier3>
+    {
+        IToastNotifier3(std::nullptr_t = nullptr) noexcept {}
+        IToastNotifier3(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserNotification :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserNotification>
+    {
+        IUserNotification(std::nullptr_t = nullptr) noexcept {}
+        IUserNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) IUserNotificationChangedEventArgs :
+        Windows::Foundation::IInspectable,
+        impl::consume_t<IUserNotificationChangedEventArgs>
+    {
+        IUserNotificationChangedEventArgs(std::nullptr_t = nullptr) noexcept {}
+        IUserNotificationChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/winrt/impl/Windows.UI.Notifications.2.h

@@ -0,0 +1,263 @@
+// C++/WinRT v2.0.190620.2
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef WINRT_Windows_UI_Notifications_2_H
+#define WINRT_Windows_UI_Notifications_2_H
+#include "Windows.Data.Xml.Dom.1.h"
+#include "Windows.Foundation.1.h"
+#include "Windows.Foundation.Collections.1.h"
+#include "Windows.System.1.h"
+#include "Windows.UI.Notifications.1.h"
+namespace winrt::Windows::UI::Notifications
+{
+    struct __declspec(empty_bases) AdaptiveNotificationText : Windows::UI::Notifications::IAdaptiveNotificationText,
+        impl::require<AdaptiveNotificationText, Windows::UI::Notifications::IAdaptiveNotificationContent>
+    {
+        AdaptiveNotificationText(std::nullptr_t) noexcept {}
+        AdaptiveNotificationText(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IAdaptiveNotificationText(ptr, take_ownership_from_abi) {}
+        AdaptiveNotificationText();
+    };
+    struct __declspec(empty_bases) BadgeNotification : Windows::UI::Notifications::IBadgeNotification
+    {
+        BadgeNotification(std::nullptr_t) noexcept {}
+        BadgeNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IBadgeNotification(ptr, take_ownership_from_abi) {}
+        BadgeNotification(Windows::Data::Xml::Dom::XmlDocument const& content);
+    };
+    struct BadgeUpdateManager
+    {
+        BadgeUpdateManager() = delete;
+        static auto CreateBadgeUpdaterForApplication();
+        static auto CreateBadgeUpdaterForApplication(param::hstring const& applicationId);
+        static auto CreateBadgeUpdaterForSecondaryTile(param::hstring const& tileId);
+        static auto GetTemplateContent(Windows::UI::Notifications::BadgeTemplateType const& type);
+        static auto GetForUser(Windows::System::User const& user);
+    };
+    struct __declspec(empty_bases) BadgeUpdateManagerForUser : Windows::UI::Notifications::IBadgeUpdateManagerForUser
+    {
+        BadgeUpdateManagerForUser(std::nullptr_t) noexcept {}
+        BadgeUpdateManagerForUser(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IBadgeUpdateManagerForUser(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) BadgeUpdater : Windows::UI::Notifications::IBadgeUpdater
+    {
+        BadgeUpdater(std::nullptr_t) noexcept {}
+        BadgeUpdater(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IBadgeUpdater(ptr, take_ownership_from_abi) {}
+    };
+    struct KnownAdaptiveNotificationHints
+    {
+        KnownAdaptiveNotificationHints() = delete;
+        [[nodiscard]] static auto Style();
+        [[nodiscard]] static auto Wrap();
+        [[nodiscard]] static auto MaxLines();
+        [[nodiscard]] static auto MinLines();
+        [[nodiscard]] static auto TextStacking();
+        [[nodiscard]] static auto Align();
+    };
+    struct KnownAdaptiveNotificationTextStyles
+    {
+        KnownAdaptiveNotificationTextStyles() = delete;
+        [[nodiscard]] static auto Caption();
+        [[nodiscard]] static auto Body();
+        [[nodiscard]] static auto Base();
+        [[nodiscard]] static auto Subtitle();
+        [[nodiscard]] static auto Title();
+        [[nodiscard]] static auto Subheader();
+        [[nodiscard]] static auto Header();
+        [[nodiscard]] static auto TitleNumeral();
+        [[nodiscard]] static auto SubheaderNumeral();
+        [[nodiscard]] static auto HeaderNumeral();
+        [[nodiscard]] static auto CaptionSubtle();
+        [[nodiscard]] static auto BodySubtle();
+        [[nodiscard]] static auto BaseSubtle();
+        [[nodiscard]] static auto SubtitleSubtle();
+        [[nodiscard]] static auto TitleSubtle();
+        [[nodiscard]] static auto SubheaderSubtle();
+        [[nodiscard]] static auto SubheaderNumeralSubtle();
+        [[nodiscard]] static auto HeaderSubtle();
+        [[nodiscard]] static auto HeaderNumeralSubtle();
+    };
+    struct KnownNotificationBindings
+    {
+        KnownNotificationBindings() = delete;
+        [[nodiscard]] static auto ToastGeneric();
+    };
+    struct __declspec(empty_bases) Notification : Windows::UI::Notifications::INotification
+    {
+        Notification(std::nullptr_t) noexcept {}
+        Notification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::INotification(ptr, take_ownership_from_abi) {}
+        Notification();
+    };
+    struct __declspec(empty_bases) NotificationBinding : Windows::UI::Notifications::INotificationBinding
+    {
+        NotificationBinding(std::nullptr_t) noexcept {}
+        NotificationBinding(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::INotificationBinding(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) NotificationData : Windows::UI::Notifications::INotificationData
+    {
+        NotificationData(std::nullptr_t) noexcept {}
+        NotificationData(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::INotificationData(ptr, take_ownership_from_abi) {}
+        NotificationData();
+        NotificationData(param::iterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const& initialValues, uint32_t sequenceNumber);
+        NotificationData(param::iterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const& initialValues);
+    };
+    struct __declspec(empty_bases) NotificationVisual : Windows::UI::Notifications::INotificationVisual
+    {
+        NotificationVisual(std::nullptr_t) noexcept {}
+        NotificationVisual(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::INotificationVisual(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ScheduledTileNotification : Windows::UI::Notifications::IScheduledTileNotification
+    {
+        ScheduledTileNotification(std::nullptr_t) noexcept {}
+        ScheduledTileNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IScheduledTileNotification(ptr, take_ownership_from_abi) {}
+        ScheduledTileNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime);
+    };
+    struct __declspec(empty_bases) ScheduledToastNotification : Windows::UI::Notifications::IScheduledToastNotification,
+        impl::require<ScheduledToastNotification, Windows::UI::Notifications::IScheduledToastNotification2, Windows::UI::Notifications::IScheduledToastNotification3, Windows::UI::Notifications::IScheduledToastNotification4>
+    {
+        ScheduledToastNotification(std::nullptr_t) noexcept {}
+        ScheduledToastNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IScheduledToastNotification(ptr, take_ownership_from_abi) {}
+        ScheduledToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime);
+        ScheduledToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime, Windows::Foundation::TimeSpan const& snoozeInterval, uint32_t maximumSnoozeCount);
+    };
+    struct __declspec(empty_bases) ScheduledToastNotificationShowingEventArgs : Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs
+    {
+        ScheduledToastNotificationShowingEventArgs(std::nullptr_t) noexcept {}
+        ScheduledToastNotificationShowingEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ShownTileNotification : Windows::UI::Notifications::IShownTileNotification
+    {
+        ShownTileNotification(std::nullptr_t) noexcept {}
+        ShownTileNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IShownTileNotification(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) TileFlyoutNotification : Windows::UI::Notifications::ITileFlyoutNotification
+    {
+        TileFlyoutNotification(std::nullptr_t) noexcept {}
+        TileFlyoutNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::ITileFlyoutNotification(ptr, take_ownership_from_abi) {}
+        TileFlyoutNotification(Windows::Data::Xml::Dom::XmlDocument const& content);
+    };
+    struct TileFlyoutUpdateManager
+    {
+        TileFlyoutUpdateManager() = delete;
+        static auto CreateTileFlyoutUpdaterForApplication();
+        static auto CreateTileFlyoutUpdaterForApplication(param::hstring const& applicationId);
+        static auto CreateTileFlyoutUpdaterForSecondaryTile(param::hstring const& tileId);
+        static auto GetTemplateContent(Windows::UI::Notifications::TileFlyoutTemplateType const& type);
+    };
+    struct __declspec(empty_bases) TileFlyoutUpdater : Windows::UI::Notifications::ITileFlyoutUpdater
+    {
+        TileFlyoutUpdater(std::nullptr_t) noexcept {}
+        TileFlyoutUpdater(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::ITileFlyoutUpdater(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) TileNotification : Windows::UI::Notifications::ITileNotification
+    {
+        TileNotification(std::nullptr_t) noexcept {}
+        TileNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::ITileNotification(ptr, take_ownership_from_abi) {}
+        TileNotification(Windows::Data::Xml::Dom::XmlDocument const& content);
+    };
+    struct TileUpdateManager
+    {
+        TileUpdateManager() = delete;
+        static auto CreateTileUpdaterForApplication();
+        static auto CreateTileUpdaterForApplication(param::hstring const& applicationId);
+        static auto CreateTileUpdaterForSecondaryTile(param::hstring const& tileId);
+        static auto GetTemplateContent(Windows::UI::Notifications::TileTemplateType const& type);
+        static auto GetForUser(Windows::System::User const& user);
+    };
+    struct __declspec(empty_bases) TileUpdateManagerForUser : Windows::UI::Notifications::ITileUpdateManagerForUser
+    {
+        TileUpdateManagerForUser(std::nullptr_t) noexcept {}
+        TileUpdateManagerForUser(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::ITileUpdateManagerForUser(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) TileUpdater : Windows::UI::Notifications::ITileUpdater,
+        impl::require<TileUpdater, Windows::UI::Notifications::ITileUpdater2>
+    {
+        TileUpdater(std::nullptr_t) noexcept {}
+        TileUpdater(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::ITileUpdater(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastActivatedEventArgs : Windows::UI::Notifications::IToastActivatedEventArgs,
+        impl::require<ToastActivatedEventArgs, Windows::UI::Notifications::IToastActivatedEventArgs2>
+    {
+        ToastActivatedEventArgs(std::nullptr_t) noexcept {}
+        ToastActivatedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastActivatedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastCollection : Windows::UI::Notifications::IToastCollection
+    {
+        ToastCollection(std::nullptr_t) noexcept {}
+        ToastCollection(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastCollection(ptr, take_ownership_from_abi) {}
+        ToastCollection(param::hstring const& collectionId, param::hstring const& displayName, param::hstring const& launchArgs, Windows::Foundation::Uri const& iconUri);
+    };
+    struct __declspec(empty_bases) ToastCollectionManager : Windows::UI::Notifications::IToastCollectionManager
+    {
+        ToastCollectionManager(std::nullptr_t) noexcept {}
+        ToastCollectionManager(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastCollectionManager(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastDismissedEventArgs : Windows::UI::Notifications::IToastDismissedEventArgs
+    {
+        ToastDismissedEventArgs(std::nullptr_t) noexcept {}
+        ToastDismissedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastDismissedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastFailedEventArgs : Windows::UI::Notifications::IToastFailedEventArgs
+    {
+        ToastFailedEventArgs(std::nullptr_t) noexcept {}
+        ToastFailedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastFailedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastNotification : Windows::UI::Notifications::IToastNotification,
+        impl::require<ToastNotification, Windows::UI::Notifications::IToastNotification2, Windows::UI::Notifications::IToastNotification3, Windows::UI::Notifications::IToastNotification4, Windows::UI::Notifications::IToastNotification6>
+    {
+        ToastNotification(std::nullptr_t) noexcept {}
+        ToastNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastNotification(ptr, take_ownership_from_abi) {}
+        ToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content);
+    };
+    struct __declspec(empty_bases) ToastNotificationActionTriggerDetail : Windows::UI::Notifications::IToastNotificationActionTriggerDetail
+    {
+        ToastNotificationActionTriggerDetail(std::nullptr_t) noexcept {}
+        ToastNotificationActionTriggerDetail(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastNotificationActionTriggerDetail(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastNotificationHistory : Windows::UI::Notifications::IToastNotificationHistory,
+        impl::require<ToastNotificationHistory, Windows::UI::Notifications::IToastNotificationHistory2>
+    {
+        ToastNotificationHistory(std::nullptr_t) noexcept {}
+        ToastNotificationHistory(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastNotificationHistory(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastNotificationHistoryChangedTriggerDetail : Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail,
+        impl::require<ToastNotificationHistoryChangedTriggerDetail, Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail2>
+    {
+        ToastNotificationHistoryChangedTriggerDetail(std::nullptr_t) noexcept {}
+        ToastNotificationHistoryChangedTriggerDetail(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail(ptr, take_ownership_from_abi) {}
+    };
+    struct ToastNotificationManager
+    {
+        ToastNotificationManager() = delete;
+        static auto CreateToastNotifier();
+        static auto CreateToastNotifier(param::hstring const& applicationId);
+        static auto GetTemplateContent(Windows::UI::Notifications::ToastTemplateType const& type);
+        [[nodiscard]] static auto History();
+        static auto GetForUser(Windows::System::User const& user);
+        static auto ConfigureNotificationMirroring(Windows::UI::Notifications::NotificationMirroring const& value);
+        static auto GetDefault();
+    };
+    struct __declspec(empty_bases) ToastNotificationManagerForUser : Windows::UI::Notifications::IToastNotificationManagerForUser,
+        impl::require<ToastNotificationManagerForUser, Windows::UI::Notifications::IToastNotificationManagerForUser2>
+    {
+        ToastNotificationManagerForUser(std::nullptr_t) noexcept {}
+        ToastNotificationManagerForUser(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastNotificationManagerForUser(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) ToastNotifier : Windows::UI::Notifications::IToastNotifier,
+        impl::require<ToastNotifier, Windows::UI::Notifications::IToastNotifier2, Windows::UI::Notifications::IToastNotifier3>
+    {
+        ToastNotifier(std::nullptr_t) noexcept {}
+        ToastNotifier(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IToastNotifier(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) UserNotification : Windows::UI::Notifications::IUserNotification
+    {
+        UserNotification(std::nullptr_t) noexcept {}
+        UserNotification(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IUserNotification(ptr, take_ownership_from_abi) {}
+    };
+    struct __declspec(empty_bases) UserNotificationChangedEventArgs : Windows::UI::Notifications::IUserNotificationChangedEventArgs
+    {
+        UserNotificationChangedEventArgs(std::nullptr_t) noexcept {}
+        UserNotificationChangedEventArgs(void* ptr, take_ownership_from_abi_t) noexcept : Windows::UI::Notifications::IUserNotificationChangedEventArgs(ptr, take_ownership_from_abi) {}
+    };
+}
+#endif

plugins/windows-notification/yolort/include/winrt/yolort_impl/yolo.ipp

@@ -0,0 +1,133 @@
+
+// Copyright © 2021, mjk <yuubi-san@users.noreply.github.com>
+
+// It is safe to assume that every other line
+// here has UB (but refer to the filename).
+
+#ifndef YOLORT_WRAP_IPP
+#define YOLORT_WRAP_IPP
+
+// just microsoft things
+#if __has_include(<version>)
+#include <version>     // for __cpp_lib_coroutine in winrt/base.h
+#endif
+#include <cstring>     // for memcmp in winrt/base.h
+#include <cstddef>
+using std::nullptr_t;  // for unqualified nullptr_t in winrt/base.h
+#include <climits>     // for UINT_MAX in winrt/base.h
+#include <cassert>
+
+namespace yolort
+{
+  inline void memcpy(
+    void *      const dst,
+    std::size_t const dstsize [[maybe_unused]],
+    const void *const src,
+    std::size_t const srcsize ) noexcept
+  {
+    assert( dst );
+    assert( src );
+    assert( srcsize <= dstsize );
+    std::memcpy( dst, src, srcsize );
+  }
+}
+
+
+#include <intrin.h>
+// work around the `undefined reference to _ReturnAddress` for now...
+#define _ReturnAddress() __builtin_return_address(0)
+#include <cstdint>
+// mingw apparently doesn't(?) yet implement this one as of gcc 10:
+template<typename Dummy = int>
+inline unsigned char _InterlockedCompareExchange128(
+  std::int64_t volatile *const pcurrent,
+  std::int64_t const desired_hi,
+  std::int64_t const desired_lo,
+  std::int64_t *const pexpected ) noexcept
+{
+#ifdef _WIN64
+  return __sync_bool_compare_and_swap
+  (
+    reinterpret_cast<__int128_t volatile *>(pcurrent),
+    *reinterpret_cast<__int128_t *>(pexpected),
+    __int128_t{desired_hi} << 64 | desired_lo
+  );
+#else
+  static_assert( !sizeof(Dummy), "not implemented for 32-bit targets" );
+  return {};
+#endif
+}
+
+
+// just libstdc++ things
+
+#include <charconv>
+#if !defined(__cpp_lib_to_chars) or __cpp_lib_to_chars < 201611
+#include <type_traits>
+#include <sstream>
+#include <algorithm>
+namespace std
+{
+  // release the Kraken!
+
+  #if __GNUC__ < 10  // maybe 9 already has this, dunno
+  enum class chars_format
+  {
+      scientific = 0b001,
+      fixed      = 0b010,
+      hex        = 0b100,
+      general    = fixed | scientific,
+  };
+  #endif
+
+  template<
+    typename Float,
+    enable_if_t<is_floating_point_v<Float>, int> = 0
+  >
+  inline to_chars_result to_chars(
+    char *const first, char *const last,
+    Float const value,
+    chars_format const fmt [[maybe_unused]] ) noexcept
+  {
+    assert( fmt == chars_format::general );
+    try
+    {
+      ostringstream os;
+      os << value;
+      const auto &s = os.str();
+      if ( s.size() > static_cast<std::size_t>(last-first) )
+        return { last, errc::value_too_large };
+      return { copy(s.begin(), s.end(), first), {} };
+    }
+    catch ( ... )
+    {
+      return { last, errc::value_too_large };
+    }
+  }
+}
+#endif  // __cpp_lib_to_chars
+
+#endif  // YOLORT_WRAP_IPP
+
+
+#ifdef HEADER_IMPL
+  #define __pragma(...)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wattributes"
+  #pragma GCC diagnostic ignored "-Wunused-parameter"
+  #pragma GCC diagnostic ignored "-Wconversion"
+  #pragma GCC diagnostic ignored "-Wpedantic"
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+  // ^ warning: dereferencing type-punned pointer will break strict-aliasing
+  //  rules
+  //  if (result == *(int64_t*)&current_value)
+  //                ^~~~~~~~~~~~~~~~~~~~~~~~
+  #pragma GCC diagnostic ignored "-Wclass-memaccess"
+  // ^ warning: 'void* memset(void*, int, size_t)' clearing an object of type
+  //  'struct winrt::com_array<unsigned char>' with no trivial copy-assignment;
+  //  use value-initialization instead
+  // Y U NO C++, MS??
+	  #include HEADER_IMPL
+  #pragma GCC diagnostic pop
+  #undef __pragma
+#endif