Windows 10 14316 vs. 14291 WinRT API Changes

 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.ApplicationModel.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.ApplicationModel.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

+ public class Windows.ApplicationModel.EnteredBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public interface Windows.ApplicationModel.IEnteredBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public interface Windows.ApplicationModel.ILeavingBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.LeavingBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

| public class Windows.ApplicationModel.Package {
+   public IAsyncOperation<bool> VerifyContentIntegrityAsync();
| }

+ public class Windows.ApplicationModel.PackageCatalog {
+   public static PackageCatalog OpenForCurrentPackage();
+   public static PackageCatalog OpenForCurrentUser();
+   TypedEventHandler<PackageCatalog, PackageInstallingEventArgs> PackageInstalling;
+   TypedEventHandler<PackageCatalog, PackageStagingEventArgs> PackageStaging;
+   TypedEventHandler<PackageCatalog, PackageStatusChangedEventArgs> PackageStatusChanged;
+   TypedEventHandler<PackageCatalog, PackageUninstallingEventArgs> PackageUninstalling;
+   TypedEventHandler<PackageCatalog, PackageUpdatingEventArgs> PackageUpdating;
+ }

+ public class Windows.ApplicationModel.PackageInstallingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public Package Package { get; }
+   public double Progress { get; }
+ }

+ public class Windows.ApplicationModel.PackageStagingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public Package Package { get; }
+   public double Progress { get; }
+ }

+ public class Windows.ApplicationModel.PackageStatusChangedEventArgs {
+   public Package Package { get; }
+ }

+ public class Windows.ApplicationModel.PackageUninstallingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public Package Package { get; }
+   public double Progress { get; }
+ }

+ public class Windows.ApplicationModel.PackageUpdatingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public double Progress { get; }
+   public Package SourcePackage { get; }
+   public Package TargetPackage { get; }
+ }

+ public class Windows.ApplicationModel.StartupTask {
+   public StartupTaskState State { get; }
+   public string TaskId { get; }
+   public IAsyncOperation<StartupTaskState> RequestEnableAsync();
+   public void Disable();
+   public static IAsyncOperation<IVectorView<StartupTask>> GetForCurrentPackageAsync();
+   public static IAsyncOperation<StartupTask> GetAsync( string operation );
+ }

+ public struct Windows.ApplicationModel.StartupTaskContract {
+ }

+ public enum Windows.ApplicationModel.StartupTaskState {
+   Disabled = 0,
+   DisabledByUser = 1,
+   Enabled = 2,
+ }

| public enum Windows.ApplicationModel.Activation.ActivationKind {
+   UserDataAccountsProvider = 1014,
+   FilePickerExperience = 1015,
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderAddAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderRemoveAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderReplaceAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderShowTimeFrameActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs {
+   public IBackgroundTaskInstance TaskInstance { get; }
+ }

| public class Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.DeviceActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.DevicePairingActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.DialReceiverActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileOpenPickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileSavePickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FolderPickerContinuationEventArgs {
+   public User User { get; }
| }

+ public interface Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser {
+   public User User { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs {
+   public IBackgroundTaskInstance TaskInstance { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs2 {
+   public TileActivatedInfo TileActivatedInfo { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IUserDataAccountProviderActivatedEventArgs {
+   public IUserDataAccountProviderOperation Operation { get; }
+ }

| public class Windows.ApplicationModel.Activation.LaunchActivatedEventArgs {
+   public User User { get; }
+   public TileActivatedInfo TileActivatedInfo { get; }
| }

| public class Windows.ApplicationModel.Activation.LockScreenActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.ProtocolActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.ProtocolForResultsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.RestrictedLaunchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.SearchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.ApplicationModel.Activation.TileActivatedInfo {
+   public IVectorView<ShownTileNotification> RecentlyShownNotifications { get; }
+ }

| public class Windows.ApplicationModel.Activation.ToastNotificationActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.ApplicationModel.Activation.UserDataAccountProviderActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public IUserDataAccountProviderOperation Operation { get; }
+ }

| public class Windows.ApplicationModel.Activation.VoiceCommandActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.WebAccountProviderActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.AppService.AppServiceConnection {
+   public User User { get; set; }
+   public IAsyncOperation<AppServiceConnectionStatus> OpenRemoteAsync( RemoteSystemConnectionRequest operation );
| }

| public enum Windows.ApplicationModel.AppService.AppServiceConnectionStatus {
+   RemoteSystemUnavailable = 5,
+   RemoteSystemNotSupportedByApp = 6,
+   NotAuthorized = 7,
| }

| public enum Windows.ApplicationModel.AppService.AppServiceResponseStatus {
+   RemoteSystemUnavailable = 4,
+   MessageSizeTooLarge = 5,
| }

| public class Windows.ApplicationModel.AppService.AppServiceTriggerDetails {
+   public bool IsRemoteSystemConnection { get; }
| }

| public enum Windows.ApplicationModel.Appointments.AppointmentCalendarOtherAppReadAccess {
+   None = 3,
| }

| public class Windows.ApplicationModel.Appointments.AppointmentManager {
+   public static AppointmentManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<string> ShowAddAppointmentAsync( Appointment result, Rect appointment );
+   public IAsyncOperation<string> ShowAddAppointmentAsync( Appointment result, Rect appointment, Placement selection );
+   public IAsyncOperation<string> ShowReplaceAppointmentAsync( string result, Appointment appointmentId, Rect appointment );
+   public IAsyncOperation<string> ShowReplaceAppointmentAsync( string result, Appointment appointmentId, Rect appointment, Placement selection );
+   public IAsyncOperation<string> ShowReplaceAppointmentAsync( string result, Appointment appointmentId, Rect appointment, Placement selection, DateTime preferredPlacement );
+   public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string result, Rect appointmentId );
+   public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string result, Rect appointmentId, Placement selection );
+   public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string result, Rect appointmentId, Placement selection, DateTime preferredPlacement );
+   public IAsyncAction ShowTimeFrameAsync( DateTime result, TimeSpan timeToShow );
+   public IAsyncAction ShowAppointmentDetailsAsync( string result );
+   public IAsyncAction ShowAppointmentDetailsAsync( string result, DateTime appointmentId );
+   public IAsyncOperation<string> ShowEditNewAppointmentAsync( Appointment result );
+   public IAsyncOperation<AppointmentStore> RequestStoreAsync( AppointmentStoreAccessType result );
+ }

| public enum Windows.ApplicationModel.Background.BackgroundAccessStatus {
+   AlwaysAllowed = 4,
+   AllowedSubjectToSystemPolicy = 5,
+   DeniedBySystemPolicy = 6,
+   DeniedByUser = 7,
| }

+ public interface Windows.ApplicationModel.Background.IBackgroundTaskInstance4 {
+   public User User { get; }
+ }

+ public class Windows.ApplicationModel.Background.SecondaryAuthenticationFactorAuthenticationTrigger {
+   public SecondaryAuthenticationFactorAuthenticationTrigger();
+ }

| public class Windows.ApplicationModel.Background.SocketActivityTrigger {
+   public bool IsWakeFromLowPowerSupported { get; }
| }

| public enum Windows.ApplicationModel.Background.SystemTriggerType {
+   DefaultSignInAccountChange = 15,
| }

+ public class Windows.ApplicationModel.Background.UserNotificationChangedTrigger {
+   public UserNotificationChangedTrigger( NotificationKinds notificationKinds );
+ }

| public class Windows.ApplicationModel.Calls.PhoneCallHistoryManager {
+   public static PhoneCallHistoryManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Calls.PhoneCallHistoryManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<PhoneCallHistoryStore> RequestStoreAsync( PhoneCallHistoryStoreAccessType result );
+ }

| public class Windows.ApplicationModel.Chat.ChatConversation {
+   public ChatItemKind ItemKind { get; }
| }

| public class Windows.ApplicationModel.Chat.ChatMessage {
+   public ChatItemKind ItemKind { get; }
| }

| public enum Windows.ApplicationModel.Contacts.ContactCardTabKind {
+   OrganizationalHierarchy = 5,
| }

| public class Windows.ApplicationModel.Contacts.ContactList {
+   public ContactListSyncConstraints SyncConstraints { get; }
-   public ContactListConstraints Constraints { get; }
| }

- public class Windows.ApplicationModel.Contacts.ContactListConstraints;

| public enum Windows.ApplicationModel.Contacts.ContactListOtherAppReadAccess {
+   None = 3,
| }

+ public class Windows.ApplicationModel.Contacts.ContactListSyncConstraints {
+   public bool CanSyncDescriptions { get; set; }
+   public IReference<int> MaxCompanyPhoneNumbers { get; set; }
+   public IReference<int> MaxChildRelationships { get; set; }
+   public IReference<int> MaxBusinessFaxPhoneNumbers { get; set; }
+   public IReference<int> MaxBirthdayDates { get; set; }
+   public IReference<int> MaxAssistantPhoneNumbers { get; set; }
+   public IReference<int> MaxOtherAddresses { get; set; }
+   public IReference<int> MaxAnniversaryDates { get; set; }
+   public IReference<int> MaxHomeAddresses { get; set; }
+   public IReference<int> MaxOtherDates { get; set; }
+   public IReference<int> MaxMobilePhoneNumbers { get; set; }
+   public IReference<int> MaxJobInfo { get; set; }
+   public IReference<int> MaxHomePhoneNumbers { get; set; }
+   public IReference<int> MaxHomeFaxPhoneNumbers { get; set; }
+   public IReference<int> MaxOtherEmailAddresses { get; set; }
+   public IReference<int> MaxPersonalEmailAddresses { get; set; }
+   public IReference<int> MaxPartnerRelationships { get; set; }
+   public IReference<int> MaxParentRelationships { get; set; }
+   public IReference<int> MaxPagerPhoneNumbers { get; set; }
+   public IReference<int> MaxOtherRelationships { get; set; }
+   public IReference<int> MaxOtherPhoneNumbers { get; set; }
+   public IReference<int> MaxRadioPhoneNumbers { get; set; }
+   public IReference<int> MaxWorkPhoneNumbers { get; set; }
+   public IReference<int> MaxWorkEmailAddresses { get; set; }
+   public IReference<int> MaxWorkAddresses { get; set; }
+   public IReference<int> MaxWebsites { get; set; }
+   public IReference<int> MaxSpouseRelationships { get; set; }
+   public IReference<int> MaxSiblingRelationships { get; set; }
+ }

| public class Windows.ApplicationModel.Contacts.ContactManager {
+   public static ContactManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Contacts.ContactManagerForUser {
+   public ContactNameOrder SystemSortOrder { get; set; }
+   public ContactNameOrder SystemDisplayNameOrder { get; set; }
+   public User User { get; }
+   public IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact result );
+   public IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact result, uint contact );
+   public IAsyncOperation<Contact> ConvertVCardToContactAsync( IRandomAccessStreamReference result );
+   public IAsyncOperation<ContactStore> RequestStoreAsync( ContactStoreAccessType result );
+   public IAsyncOperation<ContactAnnotationStore> RequestAnnotationStoreAsync( ContactAnnotationStoreAccessType result );
+ }

| public class Windows.ApplicationModel.DataTransfer.DataTransferManager {
+   public static bool IsSupported();
| }

| public enum Windows.ApplicationModel.Email.EmailMailboxOtherAppReadAccess {
+   None = 2,
| }

| public class Windows.ApplicationModel.Email.EmailManager {
+   public static EmailManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Email.EmailManagerForUser {
+   public User User { get; }
+   public IAsyncAction ShowComposeNewEmailAsync( EmailMessage result );
+   public IAsyncOperation<EmailStore> RequestStoreAsync( EmailStoreAccessType result );
+ }

+ public class Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs {
+   public int ViewId { get; }
+ }

+ public class Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs {
+   public bool IsVisible { get; }
+   public int ViewId { get; }
+ }

+ public class Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview {
+   public bool IsScreenLocked { get; }
+   public void ShowNote( int noteViewId );
+   public void ShowNoteRelativeTo( int noteViewId, int anchorNoteViewId );
+   public void ShowNoteWithPlacement( int noteViewId, IBuffer data );
+   public void HideNote( int noteViewId );
+   public IBuffer GetNotePlacement( int data );
+   public bool TrySetNoteSize( int succeeded, Size noteViewId );
+   public void SetFocusToNextView();
+   public IAsyncAction SetNotesThumbnailAsync( IBuffer operation );
+   public static NotesWindowManagerPreview GetForCurrentApp();
+   TypedEventHandler<NotesWindowManagerPreview, NotePlacementChangedPreviewEventArgs> NotePlacementChanged;
+   TypedEventHandler<NotesWindowManagerPreview, NoteVisibilityChangedPreviewEventArgs> NoteVisibilityChanged;
+   TypedEventHandler<NotesWindowManagerPreview, object> SystemLockStateChanged;
+ }

+ public struct Windows.ApplicationModel.Preview.Notes.PreviewNotesContract {
+ }

- public class Windows.ApplicationModel.Store.PackageUpdate;

- public class Windows.ApplicationModel.Store.PackageUpdateManager;

- public class Windows.ApplicationModel.Store.PackageUpdateResult;

- public enum Windows.ApplicationModel.Store.PackageUpdateState;

- public struct Windows.ApplicationModel.Store.PackageUpdateStatus;

| public class Windows.ApplicationModel.Store.Preview.StoreConfiguration {
+   public static bool HasStoreWebAccount();
+   public static bool HasStoreWebAccountForUser( User value );
+   public static IAsyncOperation<IInputStream> GetStoreLogDataAsync( bool operation, uint elevated );
| }

| public enum Windows.ApplicationModel.Store.Preview.StoreSystemFeature {
+   Memory4GB = 24,
+   Memory6GB = 25,
+   Memory8GB = 26,
+   Memory12GB = 27,
+   Memory16GB = 28,
+   Memory20GB = 29,
+   VideoMemory2GB = 30,
+   VideoMemory4GB = 31,
+   VideoMemory6GB = 32,
| }

| public class Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager {
+   public IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync( string operation, string productId, string catalogId, string flightId, bool clientId, bool repair, string forceUseOfNonRemovableStorage, PackageVolume correlationVector );
+   public IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync( User operation, string user, string productId, string catalogId, string flightId, bool clientId, bool repair, string forceUseOfNonRemovableStorage, PackageVolume correlationVector );
+   public IAsyncOperation<AppInstallItem> UpdateAppByPackageFamilyNameForUserAsync( User operation, string user, string packageFamilyName );
+   public IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync( User operation, string user, string productId, string skuId, string catalogId );
+   public IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync( User operation, string user );
+   public IAsyncOperation<bool> GetIsAppAllowedToInstallForUserAsync( User operation, string user, string productId, string skuId, string catalogId );
+   public IAsyncOperation<bool> GetIsApplicableForUserAsync( User operation, string user, string productId );
| }

| public class Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallStatus {
+   public bool ReadyForLaunch { get; }
+   public User User { get; }
| }

| public class Windows.ApplicationModel.UserDataAccounts.UserDataAccount {
+   public string DisplayName { get; set; }
+   public IVector<string> ExplictReadAccessPackageFamilyNames { get; }
| }

| public class Windows.ApplicationModel.UserDataAccounts.UserDataAccountManager {
+   public static UserDataAccountManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.UserDataAccounts.UserDataAccountManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<UserDataAccountStore> RequestStoreAsync( UserDataAccountStoreAccessType result );
+ }

| public enum Windows.ApplicationModel.UserDataAccounts.UserDataAccountOtherAppReadAccess {
+   None = 2,
| }

+ public interface Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation {
+   public UserDataAccountProviderOperationKind Kind { get; }
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountPartnerAccountInfo {
+   public UserDataAccountProviderPartnerAccountKind AccountKind { get; }
+   public string DisplayName { get; }
+   public uint Priority { get; }
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderAddAccountOperation {
+   public UserDataAccountContentKinds ContentKinds { get; }
+   public IVectorView<UserDataAccountPartnerAccountInfo> PartnerAccountInfos { get; }
+   public UserDataAccountProviderOperationKind Kind { get; }
+   public void ReportCompleted( string userDataAccountId );
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderOperationKind {
+   AddAccount = 0,
+   Settings = 1,
+   ResolveErrors = 2,
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderPartnerAccountKind {
+   Exchange = 0,
+   PopOrImap = 1,
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderResolveErrorsOperation {
+   public UserDataAccountProviderOperationKind Kind { get; }
+   public string UserDataAccountId { get; }
+   public void ReportCompleted();
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderSettingsOperation {
+   public UserDataAccountProviderOperationKind Kind { get; }
+   public string UserDataAccountId { get; }
+   public void ReportCompleted();
+ }

| public class Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration {
+   public bool IsSyncScheduleManagedBySystem { get; set; }
| }

| public class Windows.ApplicationModel.UserDataAccounts.SystemAccess.UserDataAccountSystemAccessManager {
+   public static IAsyncAction SuppressLocalAccountWithAccountAsync( string result );
-   public static IAsyncAction MakeDefaultAccountAsync( string result );
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Data.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Data.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

+ public class Windows.Data.Text.TextPhoneme {
+   public string DisplayText { get; }
+   public string ReadingText { get; }
+ }

| public class Windows.Data.Text.TextReverseConversionGenerator {
+   public IAsyncOperation<IVectorView<TextPhoneme>> GetPhonemesAsync( string result );
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Devices.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Devices.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public enum Windows.Devices.AllJoyn.AllJoynAuthenticationMechanism {
+   EcdheSpeke = 6,
| }

| public class Windows.Devices.AllJoyn.AllJoynBusAttachment {
+   public IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync( AllJoynServiceInfo operation );
+   public IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync( AllJoynServiceInfo operation, Language serviceInfo );
+   public static AllJoynBusAttachment GetDefault();
+   public static DeviceWatcher GetWatcher( IIterable<string> deviceWatcher );
| }

+ public class Windows.Devices.AllJoyn.AllJoynBusObject {
+   public AllJoynBusAttachment BusAttachment { get; }
+   public AllJoynSession Session { get; }
+   public AllJoynBusObject( string objectPath );
+   public AllJoynBusObject( string objectPath, AllJoynBusAttachment busAttachment );
+   public AllJoynBusObject();
+   public void Start();
+   public void Stop();
+   public void AddProducer( IAllJoynProducer producer );
+   TypedEventHandler<AllJoynBusObject, AllJoynBusObjectStoppedEventArgs> Stopped;
+ }

+ public class Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs {
+   public int Status { get; }
+   public AllJoynBusObjectStoppedEventArgs( int status );
+ }

| public class Windows.Devices.AllJoyn.AllJoynServiceInfo {
+   public static IAsyncOperation<AllJoynServiceInfo> FromIdAsync( string operation );
| }

+ public class Windows.Devices.AllJoyn.AllJoynSession {
+   public int Id { get; }
+   public int Status { get; }
+   public IAsyncOperation<int> RemoveMemberAsync( string operation );
+   public static IAsyncOperation<AllJoynSession> GetFromServiceInfoAsync( AllJoynServiceInfo operation );
+   public static IAsyncOperation<AllJoynSession> GetFromServiceInfoAsync( AllJoynServiceInfo operation, AllJoynBusAttachment serviceInfo );
+   TypedEventHandler<AllJoynSession, AllJoynSessionLostEventArgs> Lost;
+   TypedEventHandler<AllJoynSession, AllJoynSessionMemberAddedEventArgs> MemberAdded;
+   TypedEventHandler<AllJoynSession, AllJoynSessionMemberRemovedEventArgs> MemberRemoved;
+ }

+ public class Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs {
+   public AllJoynSession Session { get; }
+   public AllJoynSessionJoinedEventArgs( AllJoynSession session );
+ }

+ public interface Windows.Devices.AllJoyn.IAllJoynProducer {
+   public void SetBusObject( AllJoynBusObject busObject );
+ }

| public class Windows.Devices.Enumeration.EnclosureLocation {
+   public uint RotationAngleInDegreesClockwise { get; }
| }

| public class Windows.Devices.Geolocation.Geolocator {
+   public void AllowFallbackToConsentlessPositions();
| }

| public enum Windows.Devices.Geolocation.PositionSource {
+   Obfuscated = 6,
| }

| public class Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription {
+   public bool IsAbsolute { get; }
| }

| public enum Windows.Devices.Midi.MidiMessageType {
+   EndSystemExclusive = 247,
| }

| public class Windows.Devices.PointOfService.BarcodeScanner {
+   public string VideoDeviceId { get; }
| }

| public class Windows.Devices.Sensors.Accelerometer {
+   public AccelerometerReadingType ReadingType { get; }
+   public static Accelerometer GetDefault( AccelerometerReadingType result );
| }

+ public enum Windows.Devices.Sensors.AccelerometerReadingType {
+   Standard = 0,
+   Linear = 1,
+   Gravity = 2,
+ }

| public class Windows.Devices.Sensors.Inclinometer {
+   public static Inclinometer GetDefault( SensorReadingType result );
| }

| public class Windows.Devices.Sensors.OrientationSensor {
+   public static OrientationSensor GetDefault( SensorReadingType result );
+   public static OrientationSensor GetDefault( SensorReadingType result, SensorOptimizationGoal sensorReadingType );
| }

+ public enum Windows.Devices.Sensors.SensorOptimizationGoal {
+   Precision = 0,
+   PowerEfficiency = 1,
+ }

| public enum Windows.Devices.SmartCards.SmartCardReaderKind {
+   EmbeddedSE = 5,
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Foundation.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Foundation.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

+ public class Windows.Foundation.Metadata.CreateFromStringAttribute : System.Attribute {
+   public string MethodName;
+   public CreateFromStringAttribute();
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Gaming.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Gaming.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

+ public class Windows.Gaming.Input.ArcadeStick {
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public IVectorView<ArcadeStick> ArcadeSticks { get; }
+   public GameControllerButtonLabel GetButtonLabel( ArcadeStickButtons value );
+   public ArcadeStickReading GetCurrentReading();
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<ArcadeStick> ArcadeStickAdded;
+   EventHandler<ArcadeStick> ArcadeStickRemoved;
+ }

+ public enum Windows.Gaming.Input.ArcadeStickButtons {
+   None = 0,
+   StickUp = 1,
+   StickDown = 2,
+   StickLeft = 4,
+   StickRight = 8,
+   Action1 = 16,
+   Action2 = 32,
+   Action3 = 64,
+   Action4 = 128,
+   Action5 = 256,
+   Action6 = 512,
+   Special1 = 1024,
+   Special2 = 2048,
+ }

+ public struct Windows.Gaming.Input.ArcadeStickReading {
+   public ulong Timestamp;
+   public ArcadeStickButtons Buttons;
+ }

+ public enum Windows.Gaming.Input.GameControllerButtonLabel {
+   None = 0,
+   XboxBack = 1,
+   XboxStart = 2,
+   XboxMenu = 3,
+   XboxView = 4,
+   XboxUp = 5,
+   XboxDown = 6,
+   XboxLeft = 7,
+   XboxRight = 8,
+   XboxA = 9,
+   XboxB = 10,
+   XboxX = 11,
+   XboxY = 12,
+   XboxLeftBumper = 13,
+   XboxLeftTrigger = 14,
+   XboxLeftStickButton = 15,
+   XboxRightBumper = 16,
+   XboxRightTrigger = 17,
+   XboxRightStickButton = 18,
+   XboxPaddle1 = 19,
+   XboxPaddle2 = 20,
+   XboxPaddle3 = 21,
+   XboxPaddle4 = 22,
+   Mode = 23,
+   Select = 24,
+   Menu = 25,
+   View = 26,
+   Back = 27,
+   Start = 28,
+   Options = 29,
+   Share = 30,
+   Up = 31,
+   Down = 32,
+   Left = 33,
+   Right = 34,
+   LetterA = 35,
+   LetterB = 36,
+   LetterC = 37,
+   LetterL = 38,
+   LetterR = 39,
+   LetterX = 40,
+   LetterY = 41,
+   LetterZ = 42,
+   Cross = 43,
+   Circle = 44,
+   Square = 45,
+   Triangle = 46,
+   LeftBumper = 47,
+   LeftTrigger = 48,
+   LeftStickButton = 49,
+   Left1 = 50,
+   Left2 = 51,
+   Left3 = 52,
+   RightBumper = 53,
+   RightTrigger = 54,
+   RightStickButton = 55,
+   Right1 = 56,
+   Right2 = 57,
+   Right3 = 58,
+   Paddle1 = 59,
+   Paddle2 = 60,
+   Paddle3 = 61,
+   Paddle4 = 62,
+   Plus = 63,
+   Minus = 64,
+   DownLeftArrow = 65,
+   DialLeft = 66,
+   DialRight = 67,
+   Suspension = 68,
+ }

| public class Windows.Gaming.Input.Gamepad {
+   public GameControllerButtonLabel GetButtonLabel( GamepadButtons value );
| }

| public enum Windows.Gaming.Input.GamepadButtons {
+   Paddle1 = 16384,
+   Paddle2 = 32768,
+   Paddle3 = 65536,
+   Paddle4 = 131072,
| }

+ public enum Windows.Gaming.Input.OptionalUINavigationButtons {
+   None = 0,
+   Context1 = 1,
+   Context2 = 2,
+   Context3 = 4,
+   Context4 = 8,
+   PageUp = 16,
+   PageDown = 32,
+   PageLeft = 64,
+   PageRight = 128,
+   ScrollUp = 256,
+   ScrollDown = 512,
+   ScrollLeft = 1024,
+   ScrollRight = 2048,
+ }

+ public class Windows.Gaming.Input.RacingWheel {
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public bool HasClutch { get; }
+   public bool HasHandbrake { get; }
+   public bool HasPatternShifter { get; }
+   public int MaxPatternShifterGear { get; }
+   public double MaxWheelAngle { get; }
+   public ForceFeedbackMotor WheelMotor { get; }
+   public IVectorView<RacingWheel> RacingWheels { get; }
+   public GameControllerButtonLabel GetButtonLabel( RacingWheelButtons value );
+   public RacingWheelReading GetCurrentReading();
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<RacingWheel> RacingWheelAdded;
+   EventHandler<RacingWheel> RacingWheelRemoved;
+ }

+ public enum Windows.Gaming.Input.RacingWheelButtons {
+   None = 0,
+   PreviousGear = 1,
+   NextGear = 2,
+   DPadUp = 4,
+   DPadDown = 8,
+   DPadLeft = 16,
+   DPadRight = 32,
+   Button1 = 64,
+   Button2 = 128,
+   Button3 = 256,
+   Button4 = 512,
+   Button5 = 1024,
+   Button6 = 2048,
+   Button7 = 4096,
+   Button8 = 8192,
+   Button9 = 16384,
+   Button10 = 32768,
+   Button11 = 65536,
+   Button12 = 131072,
+   Button13 = 262144,
+   Button14 = 524288,
+   Button15 = 1048576,
+   Button16 = 2097152,
+ }

+ public struct Windows.Gaming.Input.RacingWheelReading {
+   public ulong Timestamp;
+   public RacingWheelButtons Buttons;
+   public int PatternShifterGear;
+   public double Wheel;
+   public double Throttle;
+   public double Brake;
+   public double Clutch;
+   public double Handbrake;
+ }

+ public enum Windows.Gaming.Input.RequiredUINavigationButtons {
+   None = 0,
+   Menu = 1,
+   View = 2,
+   Accept = 4,
+   Cancel = 8,
+   Up = 16,
+   Down = 32,
+   Left = 64,
+   Right = 128,
+ }

+ public class Windows.Gaming.Input.UINavigationController {
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public IVectorView<UINavigationController> UINavigationControllers { get; }
+   public UINavigationReading GetCurrentReading();
+   public GameControllerButtonLabel GetOptionalButtonLabel( OptionalUINavigationButtons value );
+   public GameControllerButtonLabel GetRequiredButtonLabel( RequiredUINavigationButtons value );
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<UINavigationController> UINavigationControllerAdded;
+   EventHandler<UINavigationController> UINavigationControllerRemoved;
+ }

+ public struct Windows.Gaming.Input.UINavigationReading {
+   public ulong Timestamp;
+   public RequiredUINavigationButtons RequiredButtons;
+   public OptionalUINavigationButtons OptionalButtons;
+ }

+ public class Windows.Gaming.Input.ForceFeedback.ConditionForceEffect {
+   public ConditionForceEffectKind Kind { get; }
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public ConditionForceEffect( ConditionForceEffectKind effectKind );
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 direction, float positiveCoefficient, float negativeCoefficient, float maxPositiveMagnitude, float maxNegativeMagnitude, float deadZone, float bias );
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ConditionForceEffectKind {
+   Spring = 0,
+   Damper = 1,
+   Interia = 2,
+   Friction = 3,
+ }

+ public class Windows.Gaming.Input.ForceFeedback.ConstantForceEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 vector, TimeSpan duration );
+   public void SetParametersWithEnvelope( Vector3 vector, float attackGain, float sustainGain, float releaseGain, TimeSpan startDelay, TimeSpan attackDuration, TimeSpan sustainDuration, TimeSpan releaseDuration, uint repeatCount );
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ForceFeedbackEffectAxes {
+   None = 0,
+   X = 1,
+   Y = 2,
+   Z = 4,
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ForceFeedbackEffectState {
+   Stopped = 0,
+   Running = 1,
+   Paused = 2,
+   Faulted = 3,
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ForceFeedbackLoadEffectResult {
+   Succeeded = 0,
+   EffectStorageFull = 1,
+   EffectNotSupported = 2,
+ }

+ public class Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor {
+   public double MasterGain { get; set; }
+   public bool AreEffectsPaused { get; }
+   public bool IsEnabled { get; }
+   public ForceFeedbackEffectAxes SupportedAxes { get; }
+   public IAsyncOperation<ForceFeedbackLoadEffectResult> LoadEffectAsync( IForceFeedbackEffect asyncOperation );
+   public void PauseAllEffects();
+   public void ResumeAllEffects();
+   public void StopAllEffects();
+   public IAsyncOperation<bool> TryDisableAsync();
+   public IAsyncOperation<bool> TryEnableAsync();
+   public IAsyncOperation<bool> TryResetAsync();
+   public IAsyncOperation<bool> TryUnloadEffectAsync( IForceFeedbackEffect asyncOperation );
+ }

+ public interface Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public void Start();
+   public void Stop();
+ }

+ public class Windows.Gaming.Input.ForceFeedback.PeriodicForceEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public PeriodicForceEffectKind Kind { get; }
+   public PeriodicForceEffect( PeriodicForceEffectKind effectKind );
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 vector, float frequency, float phase, float bias, TimeSpan duration );
+   public void SetParametersWithEnvelope( Vector3 vector, float frequency, float phase, float bias, float attackGain, float sustainGain, float releaseGain, TimeSpan startDelay, TimeSpan attackDuration, TimeSpan sustainDuration, TimeSpan releaseDuration, uint repeatCount );
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.PeriodicForceEffectKind {
+   SquareWave = 0,
+   SineWave = 1,
+   TriangleWave = 2,
+   SawtoothWaveUp = 3,
+   SawtoothWaveDown = 4,
+ }

+ public class Windows.Gaming.Input.ForceFeedback.RampForceEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 startVector, Vector3 endVector, TimeSpan duration );
+   public void SetParametersWithEnvelope( Vector3 startVector, Vector3 endVector, float attackGain, float sustainGain, float releaseGain, TimeSpan startDelay, TimeSpan attackDuration, TimeSpan sustainDuration, TimeSpan releaseDuration, uint repeatCount );
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Globalization.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Globalization.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.Globalization.CalendarIdentifiers {
+   public string ChineseLunar { get; }
+   public string VietnameseLunar { get; }
+   public string TaiwanLunar { get; }
+   public string KoreanLunar { get; }
+   public string JapaneseLunar { get; }
| }

+ public enum Windows.Globalization.PhoneNumberFormatting.PhoneNumberFormat {
+   E164 = 0,
+   International = 1,
+   National = 2,
+   Rfc3966 = 3,
+ }

+ public class Windows.Globalization.PhoneNumberFormatting.PhoneNumberFormatter {
+   public PhoneNumberFormatter();
+   public string Format( PhoneNumberInfo result );
+   public string Format( PhoneNumberInfo result, PhoneNumberFormat number );
+   public string FormatPartialString( string result );
+   public string FormatString( string result );
+   public string FormatStringWithLeftToRightMarkers( string result );
+   public static void TryCreate( string regionCode, ref PhoneNumberFormatter phoneNumber );
+   public static int GetCountryCodeForRegion( string result );
+   public static string GetNationalDirectDialingPrefixForRegion( string result, bool regionCode );
+   public static string WrapWithLeftToRightMarkers( string result );
+ }

+ public class Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo {
+   public int CountryCode { get; }
+   public string PhoneNumber { get; }
+   public PhoneNumberInfo( string number );
+   public int GetLengthOfGeographicalAreaCode();
+   public string GetNationalSignificantNumber();
+   public int GetLengthOfNationalDestinationCode();
+   public PredictedPhoneNumberKind PredictNumberKind();
+   public string GetGeographicRegionCode();
+   public PhoneNumberMatchResult CheckNumberMatch( PhoneNumberInfo result );
+   public string ToString();
+   public static PhoneNumberParseResult TryParse( string result, ref PhoneNumberInfo input );
+   public static PhoneNumberParseResult TryParse( string result, string input, ref PhoneNumberInfo regionCode );
+ }

+ public enum Windows.Globalization.PhoneNumberFormatting.PhoneNumberMatchResult {
+   NoMatch = 0,
+   ShortNationalSignificantNumberMatch = 1,
+   NationalSignificantNumberMatch = 2,
+   ExactMatch = 3,
+ }

+ public enum Windows.Globalization.PhoneNumberFormatting.PhoneNumberParseResult {
+   Valid = 0,
+   NotANumber = 1,
+   InvalidCountryCode = 2,
+   TooShort = 3,
+   TooLong = 4,
+ }

+ public enum Windows.Globalization.PhoneNumberFormatting.PredictedPhoneNumberKind {
+   FixedLine = 0,
+   Mobile = 1,
+   FixedLineOrMobile = 2,
+   TollFree = 3,
+   PremiumRate = 4,
+   SharedCost = 5,
+   Voip = 6,
+   PersonalNumber = 7,
+   Pager = 8,
+   UniversalAccountNumber = 9,
+   Voicemail = 10,
+   Unknown = 11,
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Graphics.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Graphics.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.Graphics.Display.DisplayInformation {
+   public uint ScreenHeightInRawPixels { get; }
+   public uint ScreenWidthInRawPixels { get; }
| }

| public class Windows.Graphics.Printing.PrintManager {
+   public static bool IsSupported();
| }

+ public class Windows.Graphics.Printing.PrintPageInfo {
+   public Size PageSize { get; set; }
+   public PrintOrientation Orientation { get; set; }
+   public PrintMediaSize MediaSize { get; set; }
+   public uint DpiY { get; set; }
+   public uint DpiX { get; set; }
+   public PrintPageInfo();
+ }

| public class Windows.Graphics.Printing.PrintTaskOptions {
+   public IRandomAccessStream GetPagePrintTicket( PrintPageInfo printTicket );
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Management.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Management.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.Management.Workplace.MdmPolicy {
+   public static MessagingSyncPolicy GetMessagingSyncPolicy();
| }

+ public enum Windows.Management.Workplace.MessagingSyncPolicy {
+   Disallowed = 0,
+   Allowed = 1,
+   Required = 2,
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Media.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Media.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.Media.MusicDisplayProperties {
+   public uint AlbumTrackCount { get; set; }
| }

| public class Windows.Media.Audio.AudioFileOutputNode {
-   public AudioNodeListener Listener { get; set; }
| }

| public class Windows.Media.Audio.AudioFrameOutputNode {
-   public AudioNodeListener Listener { get; set; }
| }

| public class Windows.Media.Audio.AudioNodeEmitter {
+   public bool IsDopplerDisabled { get; }
| }

- public interface Windows.Media.Audio.IAudioNode2;

+ public interface Windows.Media.Audio.IAudioNodeWithListener {
+   public AudioNodeListener Listener { get; set; }
+ }

- public enum Windows.Media.Capture.AppBroadcastCameraOverlayLocation;

- public enum Windows.Media.Capture.AppBroadcastCameraOverlaySize;

- public struct Windows.Media.Capture.AppBroadcastContract;

- public class Windows.Media.Capture.AppBroadcastGlobalSettings;

- public class Windows.Media.Capture.AppBroadcastManager;

- public class Windows.Media.Capture.AppBroadcastProviderSettings;

- public enum Windows.Media.Capture.AppBroadcastVideoEncodingBitrateMode;

- public enum Windows.Media.Capture.AppBroadcastVideoEncodingResolutionMode;

- public enum Windows.Media.Capture.AppCaptureCameraOverlayLocation;

- public enum Windows.Media.Capture.AppCaptureCameraOverlaySize;

| public class Windows.Media.Capture.AppCaptureSettings {
+   public AppCaptureVideoEncodingFrameRateMode VideoEncodingFrameRateMode { get; set; }
-   public string SelectedCameraId { get; set; }
-   public bool IsEchoCancellationEnabled { get; set; }
-   public bool IsCameraCaptureEnabledByDefault { get; set; }
-   public AppCaptureCameraOverlaySize CameraOverlaySize { get; set; }
-   public AppCaptureCameraOverlayLocation CameraOverlayLocation { get; set; }
| }

+ public enum Windows.Media.Capture.AppCaptureVideoEncodingFrameRateMode {
+   Standard = 0,
+   High = 1,
+ }

| public class Windows.Media.Capture.LowLagMediaRecording {
+   public IAsyncOperation<MediaCapturePauseResult> PauseWithResultAsync( MediaCapturePauseBehavior operation );
+   public IAsyncOperation<MediaCaptureStopResult> StopWithResultAsync();
| }

| public class Windows.Media.Capture.MediaCapture {
+   public IMapView<string, MediaFrameSource> FrameSources { get; }
+   public IAsyncOperation<MediaCapturePauseResult> PauseRecordWithResultAsync( MediaCapturePauseBehavior operation );
+   public IAsyncOperation<MediaCaptureStopResult> StopRecordWithResultAsync();
+   public IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync( MediaFrameSource value );
+   public IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync( MediaFrameSource value, string inputSource );
+   public IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync( MediaFrameSource value, string inputSource, BitmapSize outputSubtype );
| }

| public class Windows.Media.Capture.MediaCaptureInitializationSettings {
+   public MediaCaptureSharingMode SharingMode { get; set; }
+   public MediaFrameSourceGroup SourceGroup { get; set; }
+   public MediaCaptureMemoryPreference MemoryPreference { get; set; }
| }

+ public enum Windows.Media.Capture.MediaCaptureMemoryPreference {
+   Auto = 0,
+   Cpu = 1,
+ }

+ public class Windows.Media.Capture.MediaCapturePauseResult {
+   public VideoFrame LastFrame { get; }
+   public TimeSpan RecordDuration { get; }
+   public void Close();
+ }

+ public enum Windows.Media.Capture.MediaCaptureSharingMode {
+   ExclusiveControl = 0,
+   SharedReadOnly = 1,
+ }

+ public class Windows.Media.Capture.MediaCaptureStopResult {
+   public VideoFrame LastFrame { get; }
+   public TimeSpan RecordDuration { get; }
+   public void Close();
+ }

+ public class Windows.Media.Capture.Frames.BufferMediaFrame {
+   public IBuffer Buffer { get; }
+   public MediaFrameReference FrameReference { get; }
+ }

+ public class Windows.Media.Capture.Frames.DepthMediaFrame {
+   public DepthMediaFrameFormat DepthFormat { get; }
+   public MediaFrameReference FrameReference { get; }
+   public VideoMediaFrame VideoMediaFrame { get; }
+   public DepthCorrelatedCoordinateMapper TryCreateCoordinateMapper( CameraIntrinsics value, SpatialCoordinateSystem cameraIntrinsics );
+ }

+ public class Windows.Media.Capture.Frames.DepthMediaFrameFormat {
+   public double DepthScaleInMeters { get; }
+   public VideoMediaFrameFormat VideoFormat { get; }
+ }

+ public class Windows.Media.Capture.Frames.InfraredMediaFrame {
+   public MediaFrameReference FrameReference { get; }
+   public bool IsIlluminated { get; }
+   public VideoMediaFrame VideoMediaFrame { get; }
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs {
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameFormat {
+   public MediaRatio FrameRate { get; }
+   public string MajorType { get; }
+   public IMapView<Guid, object> Properties { get; }
+   public string Subtype { get; }
+   public VideoMediaFrameFormat VideoFormat { get; }
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameReader {
+   public MediaFrameReference TryAcquireLatestFrame();
+   public IAsyncOperation<MediaFrameReaderStartStatus> StartAsync();
+   public IAsyncAction StopAsync();
+   public void Close();
+   TypedEventHandler<MediaFrameReader, MediaFrameArrivedEventArgs> FrameArrived;
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameReaderStartStatus {
+   Success = 0,
+   UnknownFailure = 1,
+   DeviceNotAvailable = 2,
+   OutputFormatNotSupported = 3,
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameReference {
+   public BufferMediaFrame BufferMediaFrame { get; }
+   public SpatialCoordinateSystem CoordinateSystem { get; }
+   public TimeSpan Duration { get; }
+   public MediaFrameFormat Format { get; }
+   public IMapView<Guid, object> Properties { get; }
+   public MediaFrameSourceKind SourceKind { get; }
+   public IReference<TimeSpan> SystemRelativeTime { get; }
+   public VideoMediaFrame VideoMediaFrame { get; }
+   public void Close();
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSource {
+   public MediaFrameSourceController Controller { get; }
+   public MediaFrameFormat CurrentFormat { get; }
+   public MediaFrameSourceInfo Info { get; }
+   public IVectorView<MediaFrameFormat> SupportedFormats { get; }
+   public IAsyncAction SetFormatAsync( MediaFrameFormat value );
+   public CameraIntrinsics TryGetCameraIntrinsics( MediaFrameFormat value );
+   TypedEventHandler<MediaFrameSource, object> FormatChanged;
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceController {
+   public VideoDeviceController VideoDeviceController { get; }
+   public IAsyncOperation<MediaFrameSourceGetPropertyResult> GetPropertyAsync( string value );
+   public IAsyncOperation<MediaFrameSourceSetPropertyStatus> SetPropertyAsync( string value, object propertyId );
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyResult {
+   public MediaFrameSourceGetPropertyStatus Status { get; }
+   public object Value { get; }
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyStatus {
+   Success = 0,
+   UnknownFailure = 1,
+   NotSupported = 2,
+   DeviceNotAvailable = 3,
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceGroup {
+   public string DisplayName { get; }
+   public string Id { get; }
+   public IVectorView<MediaFrameSourceInfo> SourceInfos { get; }
+   public static IAsyncOperation<IVectorView<MediaFrameSourceGroup>> FindAllAsync();
+   public static IAsyncOperation<MediaFrameSourceGroup> FromIdAsync( string value );
+   public static string GetDeviceSelector();
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceInfo {
+   public SpatialCoordinateSystem CoordinateSystem { get; }
+   public DeviceInformation DeviceInformation { get; }
+   public string Id { get; }
+   public MediaStreamType MediaStreamType { get; }
+   public IMapView<Guid, object> Properties { get; }
+   public MediaFrameSourceGroup SourceGroup { get; }
+   public MediaFrameSourceKind SourceKind { get; }
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameSourceKind {
+   Custom = 0,
+   Color = 1,
+   Infrared = 2,
+   Depth = 3,
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameSourceSetPropertyStatus {
+   Success = 0,
+   UnknownFailure = 1,
+   NotSupported = 2,
+   InvalidValue = 3,
+   DeviceNotAvailable = 4,
+   NotInControl = 5,
+ }

+ public class Windows.Media.Capture.Frames.VideoMediaFrame {
+   public CameraIntrinsics CameraIntrinsics { get; }
+   public DepthMediaFrame DepthMediaFrame { get; }
+   public IDirect3DSurface Direct3DSurface { get; }
+   public MediaFrameReference FrameReference { get; }
+   public InfraredMediaFrame InfraredMediaFrame { get; }
+   public SoftwareBitmap SoftwareBitmap { get; }
+   public VideoMediaFrameFormat VideoFormat { get; }
+   public VideoFrame GetVideoFrame();
+ }

+ public class Windows.Media.Capture.Frames.VideoMediaFrameFormat {
+   public DepthMediaFrameFormat DepthFormat { get; }
+   public uint Height { get; }
+   public MediaFrameFormat MediaFrameFormat { get; }
+   public uint Width { get; }
+ }

| public class Windows.Media.Core.AudioStreamDescriptor {
+   public IReference<uint> TrailingEncoderPadding { get; set; }
+   public IReference<uint> LeadingEncoderPadding { get; set; }
-   public IReference<uint> EncoderPadding { get; set; }
-   public IReference<uint> EncoderDelay { get; set; }
| }

| public class Windows.Media.Core.MediaStreamSource {
| }

- public class Windows.Media.Core.MediaStreamSourceSampleLag;

- public class Windows.Media.Core.MediaStreamSourceSampleLagOccuredEventArgs;

+ public class Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs {
+   public TimeSpan SampleLag { get; }
+ }

| public class Windows.Media.Devices.Core.CameraIntrinsics {
+   public Matrix4x4 UndistortedProjectionTransform { get; }
+   public Point DistortPoint( Point result );
+   public void DistortPoints( Point[] inputs, Point[] results );
+   public Point UndistortPoint( Point result );
+   public void UndistortPoints( Point[] inputs, Point[] results );
| }

+ public class Windows.Media.Devices.Core.DepthCorrelatedCoordinateMapper {
+   public Vector3 UnprojectPoint( Point result, SpatialCoordinateSystem sourcePoint );
+   public void UnprojectPoints( Point[] sourcePoints, SpatialCoordinateSystem targetCoordinateSystem, Vector3[] results );
+   public Point MapPoint( Point result, SpatialCoordinateSystem sourcePoint, CameraIntrinsics targetCoordinateSystem );
+   public void MapPoints( Point[] sourcePoints, SpatialCoordinateSystem targetCoordinateSystem, CameraIntrinsics targetCameraIntrinsics, Point[] results );
+   public void Close();
+ }

- public enum Windows.Media.MediaProperties.StereoVideoPackingMode;

+ public enum Windows.Media.MediaProperties.StereoscopicVideoPackingMode {
+   None = 0,
+   SideBySide = 1,
+   TopBottom = 2,
+ }

| public class Windows.Media.MediaProperties.VideoEncodingProperties {
+   public StereoscopicVideoPackingMode StereoscopicVideoPackingMode { get; }
-   public StereoVideoPackingMode StereoVideoPackingMode { get; }
| }

- public class Windows.Media.Playback.AutoRepeatModeCommandReceivedEventArgs;

- public class Windows.Media.Playback.FastForwardCommandReceivedEventArgs;

- public enum Windows.Media.Playback.FrameStepDirection;

| public class Windows.Media.Playback.MediaBreakManager {
+   public MediaPlaybackSession PlaybackSession { get; }
| }

+ public enum Windows.Media.Playback.MediaCommandEnablingRule {
+   Auto = 0,
+   Always = 1,
+   Never = 2,
+ }

| public class Windows.Media.Playback.MediaItemDisplayProperties {
-   public RandomAccessStreamReference BackgroundArt { get; set; }
-   public void ApplyChanges();
| }

| public class Windows.Media.Playback.MediaPlaybackCommandManager {
+   public MediaPlaybackCommandManagerCommandBehavior AutoRepeatModeBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior FastForwardBehavior { get; }
+   public MediaPlayer MediaPlayer { get; }
+   public MediaPlaybackCommandManagerCommandBehavior NextBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PauseBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PlayBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PositionBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PreviousBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior RateBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior RewindBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior ShuffleBehavior { get; }
-   public PlaybackCommandEnabledBehavior PauseEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior NextEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior FastForwardEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior AutoRepeatModeEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior ShuffleEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior RewindEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior PreviousEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior PlaybackRateEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior PlaybackPositionEnabledBehavior { get; set; }
-   public PlaybackCommandEnabledBehavior PlayEnabledBehavior { get; set; }
| }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs {
+   public bool Handled { get; set; }
+   public MediaPlaybackAutoRepeatMode AutoRepeatMode { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior {
+   public MediaCommandEnablingRule EnablingRule { get; set; }
+   public MediaPlaybackCommandManager CommandManager { get; }
+   public bool IsEnabled { get; }
+   TypedEventHandler<MediaPlaybackCommandManagerCommandBehavior, object> IsEnabledChanged;
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs {
+   public bool Handled { get; set; }
+   public TimeSpan Position { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs {
+   public bool Handled { get; set; }
+   public double PlaybackRate { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs {
+   public bool Handled { get; set; }
+   public bool IsShuffleRequested { get; }
+   public Deferral GetDeferral();
+ }

| public class Windows.Media.Playback.MediaPlaybackItem {
-   public MediaItemDisplayProperties DisplayProperties { get; }
+   public MediaItemDisplayProperties GetDisplayProperties();
+   public void ApplyDisplayProperties( MediaItemDisplayProperties value );
| }

+ public class Windows.Media.Playback.MediaPlaybackSession {
+   public StereoscopicVideoPackingMode StereoscopicVideoPackingMode { get; set; }
+   public double PlaybackRate { get; set; }
+   public Rect NormalizedSourceRect { get; set; }
+   public TimeSpan Position { get; set; }
+   public bool IsProtected { get; }
+   public MediaPlayer MediaPlayer { get; }
+   public TimeSpan NaturalDuration { get; }
+   public uint NaturalVideoWidth { get; }
+   public double BufferingProgress { get; }
+   public bool CanPause { get; }
+   public bool CanSeek { get; }
+   public MediaPlaybackState PlaybackState { get; }
+   public uint NaturalVideoHeight { get; }
+   public double DownloadProgress { get; }
+   TypedEventHandler<MediaPlaybackSession, object> BufferingEnded;
+   TypedEventHandler<MediaPlaybackSession, object> BufferingProgressChanged;
+   TypedEventHandler<MediaPlaybackSession, object> BufferingStarted;
+   TypedEventHandler<MediaPlaybackSession, object> DownloadProgressChanged;
+   TypedEventHandler<MediaPlaybackSession, object> NaturalDurationChanged;
+   TypedEventHandler<MediaPlaybackSession, object> NaturalVideoSizeChanged;
+   TypedEventHandler<MediaPlaybackSession, object> PlaybackRateChanged;
+   TypedEventHandler<MediaPlaybackSession, object> PlaybackStateChanged;
+   TypedEventHandler<MediaPlaybackSession, object> PositionChanged;
+   TypedEventHandler<MediaPlaybackSession, object> SeekCompleted;
+ }

+ public enum Windows.Media.Playback.MediaPlaybackState {
+   None = 0,
+   Opening = 1,
+   Buffering = 2,
+   Playing = 3,
+   Paused = 4,
+ }

| public class Windows.Media.Playback.MediaPlayer {
+   public StereoscopicVideoRenderMode StereoscopicVideoRenderMode { get; set; }
+   public double AudioBalance { get; set; }
+   public MediaPlaybackSession PlaybackSession { get; }
-   public double Balance { get; set; }
-   public StereoVideoPackingMode StereoVideoPackingMode { get; set; }
-   public StereoVideoRenderMode StereoVideoRenderMode { get; set; }
-   public NormalizedRect PanAndZoomRect { get; set; }
-   public int NaturalVideoWidth { get; }
-   public double DownloadProgress { get; }
-   public int NaturalVideoHeight { get; }
+   public void StepForwardOneFrame();
+   public void StepBackwardOneFrame();
+   public void SetSurfaceSize( Size size );
+   public MediaPlayerSurface GetSurface( Compositor result );
+   public void AddVideoEffect( string activatableClassId, bool effectOptional, IPropertySet effectConfiguration );
-   public void FrameStep( FrameStepDirection value );
-   public MediaPlayerPlaybackStatistics GetPlaybackStatistics();
| }

- public class Windows.Media.Playback.MediaPlayerPlaybackStatistics;

+ public class Windows.Media.Playback.MediaPlayerSurface {
+   public ICompositionSurface CompositionSurface { get; }
+   public Compositor Compositor { get; }
+   public MediaPlayer MediaPlayer { get; }
+   public void Close();
+ }

- public class Windows.Media.Playback.NextCommandReceivedEventArgs;

- public struct Windows.Media.Playback.NormalizedRect;

- public class Windows.Media.Playback.PauseCommandReceivedEventArgs;

- public class Windows.Media.Playback.PlayCommandReceivedEventArgs;

- public enum Windows.Media.Playback.PlaybackCommandEnabledBehavior;

- public class Windows.Media.Playback.PlaybackPositionCommandReceivedEventArgs;

- public class Windows.Media.Playback.PlaybackRateCommandReceivedEventArgs;

- public class Windows.Media.Playback.PreviousCommandReceivedEventArgs;

- public class Windows.Media.Playback.RewindCommandReceivedEventArgs;

- public class Windows.Media.Playback.ShuffleCommandReceivedEventArgs;

- public enum Windows.Media.Playback.StereoVideoRenderMode;

+ public enum Windows.Media.Playback.StereoscopicVideoRenderMode {
+   Mono = 0,
+   Stereo = 1,
+ }

- public enum Windows.Media.Protection.HdcpLevel;

- public enum Windows.Media.Protection.HdcpLevelAsyncResultStatus;

+ public enum Windows.Media.Protection.HdcpProtection {
+   Off = 0,
+   On = 1,
+   OnWithTypeEnforcement = 2,
+ }

+ public class Windows.Media.Protection.HdcpSession {
+   public HdcpSession();
+   public bool IsEffectiveProtectionAtLeast( HdcpProtection value );
+   public IReference<HdcpProtection> GetEffectiveProtection();
+   public IAsyncOperation<HdcpSetProtectionResult> SetDesiredMinProtectionAsync( HdcpProtection value );
+   public void Close();
+   TypedEventHandler<HdcpSession, object> ProtectionChanged;
+ }

+ public enum Windows.Media.Protection.HdcpSetProtectionResult {
+   Success = 0,
+   TimedOut = 1,
+   NotSupported = 2,
+   UnknownFailure = 3,
+ }

- public class Windows.Media.Protection.HdcpSettingResult;

- public class Windows.Media.Protection.HdcpState;

| public class Windows.Media.Protection.PlayReady.PlayReadyStatics {
+   public Guid PlayReadyProtectionSystemID { get; }
+   public string PlayReadyTrustedInputActivationString { get; }
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Networking.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Networking.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager {
+   public static NetworkOperatorTetheringManager CreateFromConnectionProfile( ConnectionProfile ppManager, NetworkAdapter profile );
| }

| public enum Windows.Networking.NetworkOperators.TetheringOperationStatus {
+   BluetoothDeviceOff = 7,
+   NetworkLimitedConnectivity = 8,
| }

| public class Windows.Networking.PushNotifications.PushNotificationChannelManager {
+   public static PushNotificationChannelManagerForUser GetForUser( User result );
| }

+ public class Windows.Networking.PushNotifications.PushNotificationChannelManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<PushNotificationChannel> CreatePushNotificationChannelForApplicationAsync();
+   public IAsyncOperation<PushNotificationChannel> CreatePushNotificationChannelForApplicationAsync( string operation );
+   public IAsyncOperation<PushNotificationChannel> CreatePushNotificationChannelForSecondaryTileAsync( string operation );
+ }

| public class Windows.Networking.Sockets.ControlChannelTrigger {
+   public bool IsWakeFromLowPowerSupported { get; }
| }

+ public interface Windows.Networking.Sockets.IWebSocketControl2 {
+   public IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
+ }

+ public interface Windows.Networking.Sockets.IWebSocketInformation2 {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
+ }

| public class Windows.Networking.Sockets.MessageWebSocketControl {
+   public IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
| }

| public class Windows.Networking.Sockets.MessageWebSocketInformation {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
| }

| public class Windows.Networking.Sockets.StreamSocket {
+   public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync( HostName operation, string remoteHostName );
+   public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync( HostName operation, string remoteHostName, HostNameSortOptions remoteServiceName );
| }

| public class Windows.Networking.Sockets.StreamWebSocketControl {
+   public IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
| }

| public class Windows.Networking.Sockets.StreamWebSocketInformation {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
| }

+ public class Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
+   public void Reject();
+   public Deferral GetDeferral();
+ }

| public class Windows.Networking.Vpn.VpnDomainNameInfo {
+   public IVector<Uri> WebProxyUris { get; }
| }

+ public enum Windows.Networking.Vpn.VpnManagementConnectionStatus {
+   Disconnected = 0,
+   Disconnecting = 1,
+   Connected = 2,
+   Connecting = 3,
+ }

| public enum Windows.Networking.Vpn.VpnManagementErrorStatus {
+   CannotFindProfile = 6,
+   AlreadyDisconnecting = 7,
+   AlreadyConnected = 8,
+   GeneralAuthenticationFailure = 9,
+   EapFailure = 10,
+   SmartCardFailure = 11,
+   CertificateFailure = 12,
+   ServerConfiguration = 13,
+   NoConnection = 14,
+   ServerConnection = 15,
+   UserNamePassword = 16,
+   DnsNotResolvable = 17,
+   InvalidIP = 18,
| }

| public class Windows.Networking.Vpn.VpnNativeProfile {
+   public bool RequireVpnClientAppUI { get; set; }
+   public VpnManagementConnectionStatus ConnectionStatus { get; }
| }

| public class Windows.Networking.Vpn.VpnPlugInProfile {
+   public bool RequireVpnClientAppUI { get; set; }
+   public VpnManagementConnectionStatus ConnectionStatus { get; }
| }

| public class Windows.Networking.Vpn.VpnTrafficFilterAssignment {
-   public VpnTrafficFilterAssignment();
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Perception.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Perception.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

+ public class Windows.Perception.Automation.Core.CorePerceptionAutomation {
+   public static void SetActivationFactoryProvider( IGetActivationFactory provider );
+ }

+ public struct Windows.Perception.Automation.Core.PerceptionAutomationCoreContract {
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Security.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Security.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorAuthenticationManager {
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync( MicrosoftAccountMultiFactorSessionAuthenticationStatus asyncOperation, MicrosoftAccountMultiFactorSessionInfo sessionAuthentictionStatus );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync( MicrosoftAccountMultiFactorSessionAuthenticationStatus asyncOperation, string sessionAuthentictionStatus, string userAccountId, MicrosoftAccountMultiFactorAuthenticationType sessionId );
| }

| public enum Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorServiceResponse {
+   NgcNotSetup = 5,
+   SessionAlreadyDenied = 6,
+   SessionAlreadyApproved = 7,
+   SessionExpired = 8,
+   NgcNonceExpired = 9,
+   InvalidSessionId = 10,
+   InvalidSessionType = 11,
+   InvalidOperation = 12,
+   InvalidStateTransition = 13,
+   DeviceNotFound = 14,
+   FlowDisabled = 15,
+   SessionNotApproved = 16,
+   OperationCanceledByUser = 17,
+   NgcDisabledByServer = 18,
+   NgcKeyNotFoundOnServer = 19,
+   UIRequired = 20,
| }

| public enum Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionApprovalStatus {
+   Denied = 2,
| }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication {
+   public IBuffer DeviceConfigurationData { get; }
+   public IBuffer DeviceNonce { get; }
+   public IBuffer ServiceAuthenticationHmac { get; }
+   public IBuffer SessionNonce { get; }
+   public IAsyncOperation<SecondaryAuthenticationFactorFinishAuthenticationStatus> FinishAuthenticationAsync( IBuffer result, IBuffer deviceHmac );
+   public IAsyncAction AbortAuthenticationAsync( string result );
+   public static IAsyncAction ShowNotificationMessageAsync( string result, SecondaryAuthenticationFactorAuthenticationMessage deviceName );
+   public static IAsyncOperation<SecondaryAuthenticationFactorAuthenticationResult> StartAuthenticationAsync( string operation, IBuffer deviceId );
+   public static IAsyncOperation<SecondaryAuthenticationFactorAuthenticationStageInfo> GetAuthenticationStageInfoAsync();
+   EventHandler<SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs> AuthenticationStageChanged;
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationMessage {
+   Invalid = 0,
+   SwipeUpWelcome = 1,
+   TapWelcome = 2,
+   DeviceNeedsAttention = 3,
+   LookingForDevice = 4,
+   LookingForDevicePluggedin = 5,
+   BluetoothIsDisabled = 6,
+   NfcIsDisabled = 7,
+   WiFiIsDisabled = 8,
+   ExtraTapIsRequired = 9,
+   DisabledByPolicy = 10,
+   TapOnDeviceRequired = 11,
+   HoldFinger = 12,
+   ScanFinger = 13,
+   UnauthorizedUser = 14,
+   ReregisterRequired = 15,
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationResult {
+   public SecondaryAuthenticationFactorAuthentication Authentication { get; }
+   public SecondaryAuthenticationFactorAuthenticationStatus Status { get; }
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationScenario {
+   SignIn = 0,
+   CredentialPrompt = 1,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStage {
+   NotStarted = 0,
+   WaitingForUserConfirmation = 1,
+   CollectingCredential = 2,
+   SuspendingAuthentication = 3,
+   CredentialCollected = 4,
+   CredentialAuthenticated = 5,
+   StoppingAuthentication = 6,
+   ReadyForLock = 7,
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs {
+   public SecondaryAuthenticationFactorAuthenticationStageInfo StageInfo { get; }
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo {
+   public string DeviceId { get; }
+   public SecondaryAuthenticationFactorAuthenticationScenario Scenario { get; }
+   public SecondaryAuthenticationFactorAuthenticationStage Stage { get; }
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStatus {
+   Failed = 0,
+   Started = 1,
+   UnknownDevice = 2,
+   DisabledByPolicy = 3,
+   InvalidAuthenticationStage = 4,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorDeviceCapabilities {
+   None = 0,
+   SecureStorage = 1,
+   StoreKeys = 2,
+   ConfirmUserIntentToAuthenticate = 4,
+   SupportSecureUserPresenceCheck = 8,
+   TransmittedDataIsEncrypted = 16,
+   HMacSha256 = 32,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorDeviceFindScope {
+   User = 0,
+   AllUsers = 1,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorFinishAuthenticationStatus {
+   Failed = 0,
+   Completed = 1,
+   NonceExpired = 2,
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo {
+   public IBuffer DeviceConfigurationData { get; }
+   public string DeviceFriendlyName { get; }
+   public string DeviceId { get; }
+   public string DeviceModelNumber { get; }
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration {
+   public IAsyncAction FinishRegisteringDeviceAsync( IBuffer result );
+   public IAsyncAction AbortRegisteringDeviceAsync( string result );
+   public static IAsyncOperation<SecondaryAuthenticationFactorRegistrationResult> RequestStartRegisteringDeviceAsync( string operation, SecondaryAuthenticationFactorDeviceCapabilities deviceId, string capabilities, string deviceFriendlyName, IBuffer deviceModelNumber, IBuffer deviceKey );
+   public static IAsyncOperation<IVectorView<SecondaryAuthenticationFactorInfo>> FindAllRegisteredDeviceInfoAsync( SecondaryAuthenticationFactorDeviceFindScope deviceInfoList );
+   public static IAsyncAction UnregisterDeviceAsync( string result );
+   public static IAsyncAction UpdateDeviceConfigurationDataAsync( string result, IBuffer devieId );
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationResult {
+   public SecondaryAuthenticationFactorRegistration Registration { get; }
+   public SecondaryAuthenticationFactorRegistrationStatus Status { get; }
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationStatus {
+   Failed = 0,
+   Started = 1,
+   CanceledByUser = 2,
+   PinSetupRequired = 3,
+   DisabledByPolicy = 4,
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Services.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Services.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

+ public class Windows.Services.Store.StoreAcquireLicenseResult {
+   public HResult ExtendedError { get; }
+   public StorePackageLicense StorePackageLicense { get; }
+ }

+ public class Windows.Services.Store.StoreAppLicense {
+   public IMapView<string, StoreLicense> AddOnLicenses { get; }
+   public DateTime ExpirationDate { get; }
+   public string ExtendedJsonData { get; }
+   public bool IsActive { get; }
+   public bool IsTrial { get; }
+   public string SkuStoreId { get; }
+   public TimeSpan TrialTimeRemaining { get; }
+ }

+ public class Windows.Services.Store.StoreAvailability {
+   public string Description { get; }
+   public DateTime EndDate { get; }
+   public string ExtendedJsonData { get; }
+   public string Name { get; }
+   public StorePrice Price { get; }
+   public string StoreId { get; }
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( StorePurchaseProperties operation );
+ }

+ public class Windows.Services.Store.StoreCollectionData {
+   public DateTime AcquiredDate { get; }
+   public string CampaignId { get; }
+   public string DeveloperOfferId { get; }
+   public DateTime EndDate { get; }
+   public string ExtendedJsonData { get; }
+   public bool IsTrial { get; }
+   public DateTime StartDate { get; }
+   public TimeSpan TrialTimeRemaining { get; }
+ }

+ public class Windows.Services.Store.StoreConsumableResult {
+   public uint BalanceRemaining { get; }
+   public HResult ExtendedError { get; }
+   public StoreConsumableStatus Status { get; }
+   public Guid TrackingId { get; }
+ }

+ public enum Windows.Services.Store.StoreConsumableStatus {
+   Succeeded = 0,
+   InsufficentQuantity = 1,
+   NetworkError = 2,
+   ServerError = 3,
+ }

+ public class Windows.Services.Store.StoreContext {
+   public User User { get; }
+   public IAsyncOperation<string> GetCustomerPurchaseIdAsync( string operation, string serviceTicket );
+   public IAsyncOperation<string> GetCustomerCollectionsIdAsync( string operation, string serviceTicket );
+   public IAsyncOperation<StoreAppLicense> GetAppLicenseAsync();
+   public IAsyncOperation<StoreProductResult> GetStoreProductForCurrentAppAsync();
+   public IAsyncOperation<StoreProductQueryResult> GetStoreProductsAsync( IIterable<string> operation, IIterable<string> productKinds );
+   public IAsyncOperation<StoreProductQueryResult> GetAssociatedStoreProductsAsync( IIterable<string> operation );
+   public IAsyncOperation<StoreProductPagedQueryResult> GetAssociatedStoreProductsWithPagingAsync( IIterable<string> operation, uint productKinds );
+   public IAsyncOperation<StoreProductQueryResult> GetUserCollectionAsync( IIterable<string> operation );
+   public IAsyncOperation<StoreProductPagedQueryResult> GetUserCollectionWithPagingAsync( IIterable<string> operation, uint productKinds );
+   public IAsyncOperation<StoreConsumableResult> ReportConsumableFulfillmentAsync( string operation, uint productStoreId, Guid quantity );
+   public IAsyncOperation<StoreConsumableResult> GetConsumableBalanceRemainingAsync( string operation );
+   public IAsyncOperation<StoreAcquireLicenseResult> AcquireStoreLicenseForOptionalPackageAsync( Package operation );
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( string operation );
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( string operation, StorePurchaseProperties storeId );
+   public IAsyncOperation<IVectorView<StorePackageUpdate>> GetAppAndSupplementalStorePackageUpdatesAsync();
+   public IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadStorePackageUpdatesAsync( IIterable<StorePackageUpdate> operation );
+   public IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackageUpdatesAsync( IIterable<StorePackageUpdate> operation );
+   public IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackagesAsync( IIterable<string> operation );
+   public static StoreContext GetDefault();
+   public static StoreContext GetForUser( User value );
+   TypedEventHandler<StoreContext, object> OfflineLicensesChanged;
+ }

+ public struct Windows.Services.Store.StoreContract {
+ }

+ public class Windows.Services.Store.StoreImage {
+   public string Caption { get; }
+   public uint Height { get; }
+   public string ImagePurposeTag { get; }
+   public Uri Uri { get; }
+   public uint Width { get; }
+ }

+ public class Windows.Services.Store.StoreLicense {
+   public DateTime ExpirationDate { get; }
+   public string ExtendedJsonData { get; }
+   public bool IsActive { get; }
+   public string SkuStoreId { get; }
+ }

+ public class Windows.Services.Store.StorePackageLicense {
+   public bool IsValid { get; }
+   public Package Package { get; }
+   public void ReleaseLicense();
+   public void Close();
+   TypedEventHandler<StorePackageLicense, object> LicenseLost;
+ }

+ public class Windows.Services.Store.StorePackageUpdate {
+   public bool Mandatory { get; }
+   public Package Package { get; }
+ }

+ public class Windows.Services.Store.StorePackageUpdateResult {
+   public StorePackageUpdateState OverallState { get; }
+   public IVectorView<StorePackageUpdateStatus> StorePackageUpdateStatuses { get; }
+ }

+ public enum Windows.Services.Store.StorePackageUpdateState {
+   Pending = 0,
+   Downloading = 1,
+   Deploying = 2,
+   Completed = 3,
+   Canceled = 4,
+   OtherError = 5,
+   ErrorLowBattery = 6,
+   ErrorWiFiRecommended = 7,
+   ErrorWiFiRequired = 8,
+ }

+ public struct Windows.Services.Store.StorePackageUpdateStatus {
+   public string PackageFamilyName;
+   public ulong PackageDownloadSizeInBytes;
+   public ulong PackageBytesDownloaded;
+   public double PackageDownloadProgress;
+   public double TotalDownloadProgress;
+   public StorePackageUpdateState PackageUpdateState;
+ }

+ public class Windows.Services.Store.StorePrice {
+   public string CurrencyCode { get; }
+   public string FormattedBasePrice { get; }
+   public string FormattedPrice { get; }
+   public string FormattedRecurrencePrice { get; }
+   public bool IsOnSale { get; }
+   public DateTime SaleEndDate { get; }
+ }

+ public class Windows.Services.Store.StoreProduct {
+   public string Description { get; }
+   public string ExtendedJsonData { get; }
+   public bool HasDigitalDownload { get; }
+   public IVectorView<StoreImage> Images { get; }
+   public bool IsInUserCollection { get; }
+   public IVectorView<string> Keywords { get; }
+   public string Language { get; }
+   public Uri LinkUri { get; }
+   public StorePrice Price { get; }
+   public string ProductKind { get; }
+   public IVectorView<StoreSku> Skus { get; }
+   public string StoreId { get; }
+   public string Title { get; }
+   public IVectorView<StoreVideo> Videos { get; }
+   public IAsyncOperation<bool> GetIsAnySkuInstalledAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( StorePurchaseProperties operation );
+ }

+ public class Windows.Services.Store.StoreProductPagedQueryResult {
+   public HResult ExtendedError { get; }
+   public bool HasMoreResults { get; }
+   public IMapView<string, StoreProduct> Products { get; }
+   public IAsyncOperation<StoreProductPagedQueryResult> GetNextAsync();
+ }

+ public class Windows.Services.Store.StoreProductQueryResult {
+   public HResult ExtendedError { get; }
+   public IMapView<string, StoreProduct> Products { get; }
+ }

+ public class Windows.Services.Store.StoreProductResult {
+   public HResult ExtendedError { get; }
+   public StoreProduct Product { get; }
+ }

+ public class Windows.Services.Store.StorePurchaseProperties {
+   public string Name { get; set; }
+   public Uri ImageUri { get; set; }
+   public string ExtendedJsonData { get; set; }
+   public string Description { get; set; }
+   public StorePurchaseProperties( string name );
+   public StorePurchaseProperties();
+ }

+ public class Windows.Services.Store.StorePurchaseResult {
+   public HResult ExtendedError { get; }
+   public StorePurchaseStatus Status { get; }
+ }

+ public enum Windows.Services.Store.StorePurchaseStatus {
+   Succeeded = 0,
+   AlreadyPurchased = 1,
+   NotPurchased = 2,
+   NetworkError = 3,
+   ServerError = 4,
+ }

+ public class Windows.Services.Store.StoreRequestHelper {
+   public static IAsyncOperation<StoreSendRequestResult> SendRequestAsync( StoreContext operation, uint context, string requestKind );
+ }

+ public class Windows.Services.Store.StoreSendRequestResult {
+   public HResult ExtendedError { get; }
+   public string Response { get; }
+ }

+ public class Windows.Services.Store.StoreSku {
+   public IVectorView<StoreAvailability> Availabilities { get; }
+   public IVectorView<string> BundledSkus { get; }
+   public StoreCollectionData CollectionData { get; }
+   public string CustomDeveloperData { get; }
+   public string Description { get; }
+   public string ExtendedJsonData { get; }
+   public IVectorView<StoreImage> Images { get; }
+   public bool IsInUserCollection { get; }
+   public bool IsTrial { get; }
+   public string Language { get; }
+   public StorePrice Price { get; }
+   public string StoreId { get; }
+   public string Title { get; }
+   public IVectorView<StoreVideo> Videos { get; }
+   public IAsyncOperation<bool> GetIsInstalledAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( StorePurchaseProperties operation );
+ }

+ public class Windows.Services.Store.StoreVideo {
+   public string Caption { get; }
+   public uint Height { get; }
+   public StoreImage PreviewImage { get; }
+   public Uri Uri { get; }
+   public string VideoPurposeTag { get; }
+   public uint Width { get; }
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Storage.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Storage.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.Storage.StorageLibrary {
+   public StorageLibraryChangeTracker ChangeTracker { get; }
| }

+ public class Windows.Storage.StorageLibraryChange {
+   public StorageLibraryChangeType ChangeType { get; }
+   public string Path { get; }
+   public string PreviousPath { get; }
+   public bool IsOfType( StorageItemTypes value );
+   public IAsyncOperation<IStorageItem> GetStorageItemAsync();
+ }

+ public class Windows.Storage.StorageLibraryChangeReader {
+   public IAsyncOperation<IVectorView<StorageLibraryChange>> ReadBatchAsync();
+   public IAsyncAction AcceptChangesAsync();
+ }

+ public class Windows.Storage.StorageLibraryChangeTracker {
+   public StorageLibraryChangeReader GetChangeReader();
+   public void Enable();
+   public void Reset();
+ }

+ public enum Windows.Storage.StorageLibraryChangeType {
+   Created = 0,
+   Deleted = 1,
+   MovedOrRenamed = 2,
+   ContentsChanged = 3,
+   MovedOutOfLibrary = 4,
+   MovedIntoLibrary = 5,
+   ContentsReplaced = 6,
+   IndexingStatusChanged = 7,
+   EncryptionChanged = 8,
+   ChangeTrackingLost = 9,
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.System.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.System.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public enum Windows.System.AppMemoryUsageLevel {
+   OverLimit = 3,
| }

| public class Windows.System.Launcher {
+   public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync( Uri operation );
+   public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync( Uri operation, string uri );
+   public static IAsyncOperation<IVectorView<AppInfo>> FindAppUriHandlersAsync( Uri operation );
| }

| public class Windows.System.LauncherOptions {
+   public bool IgnoreAppUriHandlers { get; set; }
| }

+ public enum Windows.System.RemoteLaunchUriStatus {
+   Unknown = 0,
+   Success = 1,
+   AppUnavailable = 2,
+   ProtocolUnavailable = 3,
+   RemoteSystemUnavailable = 4,
+   ValueSetTooLarge = 5,
+   DeniedByLocalSystem = 6,
+   DeniedByRemoteSystem = 7,
+ }

+ public class Windows.System.RemoteLauncher {
+   public static IAsyncOperation<RemoteLaunchUriStatus> LaunchUriAsync( RemoteSystemConnectionRequest operation, Uri remoteSystemConnectionRequest );
+   public static IAsyncOperation<RemoteLaunchUriStatus> LaunchUriAsync( RemoteSystemConnectionRequest operation, Uri remoteSystemConnectionRequest, RemoteLauncherOptions uri );
+   public static IAsyncOperation<RemoteLaunchUriStatus> LaunchUriAsync( RemoteSystemConnectionRequest operation, Uri remoteSystemConnectionRequest, RemoteLauncherOptions uri, ValueSet options );
+ }

+ public class Windows.System.RemoteLauncherOptions {
+   public Uri FallbackUri { get; set; }
+   public IVector<string> PreferredAppIds { get; }
+   public RemoteLauncherOptions();
+ }

+ public class Windows.System.UserPicker {
+   public User SuggestedSelectedUser { get; set; }
+   public bool AllowGuestAccounts { get; set; }
+   public bool IsSupported { get; }
+   public UserPicker();
+   public IAsyncOperation<User> PickSingleUserAsync();
+ }

| public class Windows.System.Profile.DeviceIdentification {
+   public static DeviceIdentificationToken GetPublisherSpecificDeviceId();
+   public static DeviceIdentificationToken GetUserSpecificDeviceId( User deviceIdentificationResult );
| }

+ public enum Windows.System.Profile.DeviceIdentificationSource {
+   None = 0,
+   Tpm = 1,
+   Uefi = 2,
+ }

+ public class Windows.System.Profile.DeviceIdentificationToken {
+   public IBuffer Id { get; }
+   public DeviceIdentificationSource Source { get; }
+ }

+ public interface Windows.System.RemoteSystems.IRemoteSystemFilter {
+ }

+ public class Windows.System.RemoteSystems.RemoteSystem {
+   public string DisplayName { get; }
+   public string Id { get; }
+   public bool IsAvailableByProximity { get; }
+   public string Kind { get; }
+   public RemoteSystemStatus Status { get; }
+   public static IAsyncOperation<RemoteSystem> FindByHostNameAsync( HostName operation );
+   public static RemoteSystemWatcher CreateWatcher();
+   public static RemoteSystemWatcher CreateWatcher( IIterable<IRemoteSystemFilter> result );
+   public static IAsyncOperation<RemoteSystemAccessStatus> RequestAccessAsync();
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemAccessStatus {
+   Unspecified = 0,
+   Allowed = 1,
+   DeniedByUser = 2,
+   DeniedBySystem = 3,
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemAddedEventArgs {
+   public RemoteSystem RemoteSystem { get; }
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemConnectionRequest {
+   public RemoteSystem RemoteSystem { get; }
+   public RemoteSystemConnectionRequest( RemoteSystem remoteSystem );
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemDiscoveryType {
+   Any = 0,
+   Proximal = 1,
+   Cloud = 2,
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemDiscoveryTypeFilter {
+   public RemoteSystemDiscoveryType RemoteSystemDiscoveryType { get; }
+   public RemoteSystemDiscoveryTypeFilter( RemoteSystemDiscoveryType discoveryType );
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemKindFilter {
+   public IVectorView<string> RemoteSystemKinds { get; }
+   public RemoteSystemKindFilter( IIterable<string> remoteSystemKinds );
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemKinds {
+   public string Desktop { get; }
+   public string Holographic { get; }
+   public string Hub { get; }
+   public string Phone { get; }
+   public string Xbox { get; }
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs {
+   public string RemoteSystemId { get; }
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemStatus {
+   Unavailable = 0,
+   Available = 1,
+   DiscoveringAvailability = 2,
+   Unknown = 3,
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemStatusType {
+   Any = 0,
+   Available = 1,
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemStatusTypeFilter {
+   public RemoteSystemStatusType RemoteSystemStatusType { get; }
+   public RemoteSystemStatusTypeFilter( RemoteSystemStatusType remoteSystemStatusType );
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs {
+   public RemoteSystem RemoteSystem { get; }
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemWatcher {
+   public void Start();
+   public void Stop();
+   TypedEventHandler<RemoteSystemWatcher, RemoteSystemAddedEventArgs> RemoteSystemAdded;
+   TypedEventHandler<RemoteSystemWatcher, RemoteSystemRemovedEventArgs> RemoteSystemRemoved;
+   TypedEventHandler<RemoteSystemWatcher, RemoteSystemUpdatedEventArgs> RemoteSystemUpdated;
+ }

| public class Windows.System.UserProfile.AdvertisingManager {
+   public static AdvertisingManagerForUser GetForUser( User value );
| }

+ public class Windows.System.UserProfile.AdvertisingManagerForUser {
+   public string AdvertisingId { get; }
+   public User User { get; }
+ }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.UI.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.UI.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.UI.ApplicationSettings.AccountsSettingsPane {
+   public static IAsyncAction ShowManageAccountsAsync();
+   public static IAsyncAction ShowAddAccountAsync();
| }

+ public class Windows.UI.Composition.AmbientLight : Windows.UI.Composition.CompositionLight {
+   public Color Color { get; set; }
+ }

- public class Windows.UI.Composition.AnimationGroup : Windows.UI.Composition.CompositionObject;

| public class Windows.UI.Composition.CompositionAnimation : Windows.UI.Composition.CompositionObject {
+   public string Target { get; set; }
+   public void SetBooleanParameter( string key, bool value );
| }

+ public class Windows.UI.Composition.CompositionAnimationGroup : Windows.UI.Composition.CompositionObject {
+   public int Count { get; }
+   public void Add( CompositionAnimation value );
+   public void Remove( CompositionAnimation value );
+   public void RemoveAll();
+   public IIterator<CompositionAnimation> First();
+ }

+ public class Windows.UI.Composition.CompositionBackdropBrush : Windows.UI.Composition.CompositionBrush {
+ }

- public class Windows.UI.Composition.CompositionDestinationBrush : Windows.UI.Composition.CompositionBrush;

- public class Windows.UI.Composition.CompositionInteractionSource : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.CompositionInteractionSourceCollection : Windows.UI.Composition.CompositionObject;

+ public class Windows.UI.Composition.CompositionLight : Windows.UI.Composition.CompositionObject {
+   public VisualUnorderedCollection Targets { get; }
+ }

+ public class Windows.UI.Composition.CompositionNineGridBrush : Windows.UI.Composition.CompositionBrush {
+   public float TopInsetScale { get; set; }
+   public float TopInset { get; set; }
+   public CompositionBrush Source { get; set; }
+   public float RightInsetScale { get; set; }
+   public float RightInset { get; set; }
+   public float LeftInsetScale { get; set; }
+   public float LeftInset { get; set; }
+   public bool IsCenterHollow { get; set; }
+   public float BottomInsetScale { get; set; }
+   public float BottomInset { get; set; }
+   public void SetInsets( float inset );
+   public void SetInsets( float left, float top, float right, float bottom );
+   public void SetInsetScales( float scale );
+   public void SetInsetScales( float left, float top, float right, float bottom );
+ }

| public class Windows.UI.Composition.CompositionObject {
*   public ImplicitAnimationCollection ImplicitAnimations { get; set; }
+   public string Comment { get; set; }
+   public void StartAnimationGroup( ICompositionAnimationBase value );
+   public void StopAnimationGroup( ICompositionAnimationBase value );
| }

- public class Windows.UI.Composition.CompositionPropertyChangedEventArgs : Windows.UI.Composition.CompositionObject;

| public class Windows.UI.Composition.CompositionPropertySet : Windows.UI.Composition.CompositionObject {
+   public void InsertBoolean( string propertyName, bool value );
+   public CompositionGetValueStatus TryGetBoolean( string result, ref bool propertyName );
| }

| public class Windows.UI.Composition.Compositor {
+   public AmbientLight CreateAmbientLight();
+   public CompositionAnimationGroup CreateAnimationGroup();
+   public CompositionBackdropBrush CreateBackdropBrush();
+   public DistantLight CreateDistantLight();
+   public ImplicitAnimationCollection CreateImplicitAnimationCollection();
+   public LayerVisual CreateLayerVisual();
+   public CompositionNineGridBrush CreateNineGridBrush();
+   public PointLight CreatePointLight();
+   public SpotLight CreateSpotLight();
-   public ImplicitAnimationMap CreateImplicitAnimationMap();
-   public CompositionDestinationBrush CreateDestinationBrush();
-   public InteractionTracker CreateInteractionTracker();
-   public InteractionTrackerInertiaEndpoint CreateInteractionTrackerInertiaEndpoint();
-   public InteractionTrackerInertiaMotion CreateInteractionTrackerInertiaMotion();
| }

+ public class Windows.UI.Composition.DistantLight : Windows.UI.Composition.CompositionLight {
+   public Vector3 Direction { get; set; }
+   public Visual CoordinateSpace { get; set; }
+   public Color Color { get; set; }
+ }

| public class Windows.UI.Composition.DropShadow : Windows.UI.Composition.CompositionShadow {
+   public float Opacity { get; set; }
| }

+ public interface Windows.UI.Composition.ICompositionAnimationBase {
+ }

- public interface Windows.UI.Composition.ICompositionInteractionSource;

- public interface Windows.UI.Composition.IImplicitAnimationMapEntry;

- public interface Windows.UI.Composition.IInteractionTrackerInertiaEndpoint;

- public interface Windows.UI.Composition.IInteractionTrackerInertiaModifier;

- public interface Windows.UI.Composition.IInteractionTrackerInertiaMotion;

- public interface Windows.UI.Composition.IInteractionTrackerOwner;

+ public class Windows.UI.Composition.ImplicitAnimationCollection : Windows.UI.Composition.CompositionObject {
+   public uint Size { get; }
+   public ICompositionAnimationBase Lookup( string returnValue );
+   public bool HasKey( string returnValue );
+   public IMapView<string, ICompositionAnimationBase> GetView();
+   public bool Insert( string returnValue, ICompositionAnimationBase key );
+   public void Remove( string key );
+   public void Clear();
+   public IIterator<IKeyValuePair<string, ICompositionAnimationBase>> First();
+ }

- public class Windows.UI.Composition.ImplicitAnimationMap : Windows.UI.Composition.CompositionObject;

- public enum Windows.UI.Composition.InteractionNestingMode;

- public enum Windows.UI.Composition.InteractionSourceMode;

- public enum Windows.UI.Composition.InteractionSystemManipulationMode;

- public class Windows.UI.Composition.InteractionTracker : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.InteractionTrackerCustomAnimationStateEnteredArgs : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.InteractionTrackerIdleStateEnteredArgs : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.InteractionTrackerInContactStateEnteredArgs : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.InteractionTrackerInertiaEndpoint : Windows.UI.Composition.InteractionTrackerInertiaModifier;

- public class Windows.UI.Composition.InteractionTrackerInertiaModifier;

- public class Windows.UI.Composition.InteractionTrackerInertiaMotion : Windows.UI.Composition.InteractionTrackerInertiaModifier;

- public class Windows.UI.Composition.InteractionTrackerInertiaStateEnteredArgs : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.InteractionTrackerRequestIgnoredArgs : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.InteractionTrackerValuesChangedArgs : Windows.UI.Composition.CompositionObject;

+ public class Windows.UI.Composition.LayerVisual : Windows.UI.Composition.ContainerVisual {
+   public CompositionEffectBrush Effect { get; set; }
+ }

+ public class Windows.UI.Composition.PointLight : Windows.UI.Composition.CompositionLight {
+   public float QuadraticAttenuation { get; set; }
+   public Vector3 Offset { get; set; }
+   public float LinearAttenuation { get; set; }
+   public Visual CoordinateSpace { get; set; }
+   public float ConstantAttenuation { get; set; }
+   public Color Color { get; set; }
+ }

+ public class Windows.UI.Composition.SpotLight : Windows.UI.Composition.CompositionLight {
+   public Color InnerConeColor { get; set; }
+   public float InnerConeAngleInDegrees { get; set; }
+   public float InnerConeAngle { get; set; }
+   public Vector3 Direction { get; set; }
+   public Visual CoordinateSpace { get; set; }
+   public float ConstantAttenuation { get; set; }
+   public float QuadraticAttenuation { get; set; }
+   public Color OuterConeColor { get; set; }
+   public float OuterConeAngleInDegrees { get; set; }
+   public float OuterConeAngle { get; set; }
+   public Vector3 Offset { get; set; }
+   public float LinearAttenuation { get; set; }
+ }

| public class Windows.UI.Composition.StepEasingFunction : Windows.UI.Composition.CompositionEasingFunction {
+   public bool IsInitialStepSingleFrame { get; set; }
+   public bool IsFinalStepSingleFrame { get; set; }
+   public int InitialStep { get; set; }
+   public int FinalStep { get; set; }
-   public int StartAtStep { get; set; }
-   public bool InstantStart { get; set; }
-   public bool InstantFinish { get; set; }
-   public int FinishAtStep { get; set; }
| }

| public class Windows.UI.Composition.Visual : Windows.UI.Composition.CompositionObject {
-   public float RelativeWidth { get; set; }
-   public float RelativeOffsetY { get; set; }
-   public bool SnapToPixels { get; set; }
-   public float RelativeOffsetX { get; set; }
-   public float RelativeHeight { get; set; }
| }

- public class Windows.UI.Composition.VisualInteractionSource : Windows.UI.Composition.CompositionInteractionSource;

+ public class Windows.UI.Composition.VisualUnorderedCollection : Windows.UI.Composition.CompositionObject {
+   public int Count { get; }
+   public void Add( Visual newVisual );
+   public void Remove( Visual visual );
+   public void RemoveAll();
+   public IIterator<Visual> First();
+ }

+ public class Windows.UI.Composition.Effects.SceneLightingEffect {
+   public string Name { get; set; }
+   public float SpecularShine { get; set; }
+   public float SpecularAmount { get; set; }
+   public IGraphicsEffectSource NormalMapSource { get; set; }
+   public float DiffuseAmount { get; set; }
+   public float AmbientAmount { get; set; }
+   public SceneLightingEffect();
+ }

+ public class Windows.UI.Composition.Interactions.CompositionInteractionSourceCollection : Windows.UI.Composition.CompositionObject {
+   public int Count { get; }
+   public void Add( ICompositionInteractionSource value );
+   public void Remove( ICompositionInteractionSource value );
+   public void RemoveAll();
+   public IIterator<ICompositionInteractionSource> First();
+ }

+ public interface Windows.UI.Composition.Interactions.ICompositionInteractionSource {
+ }

+ public interface Windows.UI.Composition.Interactions.IInteractionTrackerOwner {
+   public void CustomAnimationStateEntered( InteractionTracker sender, InteractionTrackerCustomAnimationStateEnteredArgs args );
+   public void IdleStateEntered( InteractionTracker sender, InteractionTrackerIdleStateEnteredArgs args );
+   public void InertiaStateEntered( InteractionTracker sender, InteractionTrackerInertiaStateEnteredArgs args );
+   public void InteractingStateEntered( InteractionTracker sender, InteractionTrackerInteractingStateEnteredArgs args );
+   public void RequestIgnored( InteractionTracker sender, InteractionTrackerRequestIgnoredArgs args );
+   public void ValuesChanged( InteractionTracker sender, InteractionTrackerValuesChangedArgs args );
+ }

+ public enum Windows.UI.Composition.Interactions.InteractionChainingMode {
+   Auto = 0,
+   Always = 1,
+   Never = 2,
+ }

+ public enum Windows.UI.Composition.Interactions.InteractionSourceMode {
+   Disabled = 0,
+   EnabledWithInertia = 1,
+   EnabledWithoutInertia = 2,
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTracker : Windows.UI.Composition.CompositionObject {
+   public IReference<float> ScaleInertiaDecayRate { get; set; }
+   public IReference<Vector3> PositionInertiaDecayRate { get; set; }
+   public float MaxScale { get; set; }
+   public float MinScale { get; set; }
+   public Vector3 MaxPosition { get; set; }
+   public Vector3 MinPosition { get; set; }
+   public Vector3 NaturalRestingPosition { get; }
+   public float NaturalRestingScale { get; }
+   public IInteractionTrackerOwner Owner { get; }
+   public Vector3 Position { get; }
+   public CompositionInteractionSourceCollection InteractionSources { get; }
+   public Vector3 PositionVelocityInPixelsPerSecond { get; }
+   public float Scale { get; }
+   public bool IsPositionRoundingSuggested { get; }
+   public float ScaleVelocityInPercentPerSecond { get; }
+   public void AdjustPositionXIfGreaterThanThreshold( float adjustment, float positionThreshold );
+   public void AdjustPositionYIfGreaterThanThreshold( float adjustment, float positionThreshold );
+   public void ConfigurePositionXInertiaModifiers( IIterable<InteractionTrackerInertiaModifier> modifiers );
+   public void ConfigurePositionYInertiaModifiers( IIterable<InteractionTrackerInertiaModifier> modifiers );
+   public void ConfigureScaleInertiaModifiers( IIterable<InteractionTrackerInertiaModifier> modifiers );
+   public int TryUpdatePosition( Vector3 requestId );
+   public int TryUpdatePositionBy( Vector3 requestId );
+   public int TryUpdatePositionWithAnimation( CompositionAnimation requestId );
+   public int TryUpdatePositionWithAdditionalVelocity( Vector3 requestId );
+   public int TryUpdateScale( float requestId, Vector3 value );
+   public int TryUpdateScaleWithAnimation( CompositionAnimation requestId, Vector3 animation );
+   public int TryUpdateScaleWithAdditionalVelocity( float requestId, Vector3 velocityInPercentPerSecond );
+   public static InteractionTracker Create( Compositor result );
+   public static InteractionTracker CreateWithOwner( Compositor result, IInteractionTrackerOwner compositor );
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerCustomAnimationStateEnteredArgs {
+   public int RequestId { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerIdleStateEnteredArgs {
+   public int RequestId { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier : Windows.UI.Composition.CompositionObject {
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInertiaMotion : Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier {
+   public ExpressionAnimation Motion { get; set; }
+   public ExpressionAnimation Condition { get; set; }
+   public static InteractionTrackerInertiaMotion Create( Compositor result );
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInertiaRestingValue : Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier {
+   public ExpressionAnimation RestingValue { get; set; }
+   public ExpressionAnimation Condition { get; set; }
+   public static InteractionTrackerInertiaRestingValue Create( Compositor result );
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInertiaStateEnteredArgs {
+   public IReference<Vector3> ModifiedRestingPosition { get; }
+   public IReference<float> ModifiedRestingScale { get; }
+   public Vector3 NaturalRestingPosition { get; }
+   public float NaturalRestingScale { get; }
+   public Vector3 PositionVelocityInPixelsPerSecond { get; }
+   public int RequestId { get; }
+   public float ScaleVelocityInPercentPerSecond { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInteractingStateEnteredArgs {
+   public int RequestId { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerRequestIgnoredArgs {
+   public int RequestId { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerValuesChangedArgs {
+   public Vector3 Position { get; }
+   public int RequestId { get; }
+   public float Scale { get; }
+ }

+ public class Windows.UI.Composition.Interactions.VisualInteractionSource : Windows.UI.Composition.CompositionObject {
+   public InteractionSourceMode ScaleSourceMode { get; set; }
+   public InteractionChainingMode ScaleChainingMode { get; set; }
+   public InteractionSourceMode PositionYSourceMode { get; set; }
+   public InteractionChainingMode PositionYChainingMode { get; set; }
+   public InteractionSourceMode PositionXSourceMode { get; set; }
+   public InteractionChainingMode PositionXChainingMode { get; set; }
+   public VisualInteractionSourceRedirectionMode ManipulationRedirectionMode { get; set; }
+   public bool IsPositionYRailsEnabled { get; set; }
+   public bool IsPositionXRailsEnabled { get; set; }
+   public Visual Source { get; }
+   public void TryRedirectForManipulation( PointerPoint pointerPoint );
+   public static VisualInteractionSource Create( Visual result );
+ }

+ public enum Windows.UI.Composition.Interactions.VisualInteractionSourceRedirectionMode {
+   Off = 0,
+   CapableTouchpadOnly = 1,
+ }

| public class Windows.UI.Core.AcceleratorKeyEventArgs {
+   public ulong DeviceId { get; }
| }

| public class Windows.UI.Core.CoreComponentInputSource {
+   public ulong GetCurrentKeyEventDeviceId();
| }

| public class Windows.UI.Core.CoreWindow {
+   public ulong GetCurrentKeyEventDeviceId();
| }

| public class Windows.UI.Core.KeyEventArgs {
+   public ulong DeviceId { get; }
| }

+ public class Windows.UI.Input.RadialController {
+   public bool UseAutomaticHapticFeedback { get; set; }
+   public double RotationResolutionInDegrees { get; set; }
+   public RadialControllerMenu Menu { get; }
+   public static bool IsSupported();
+   public static RadialController CreateForCurrentView();
+   TypedEventHandler<RadialController, object> ControlLost;
+   TypedEventHandler<RadialController, RadialControllerRotationChangedEventArgs> RotationChanged;
+   TypedEventHandler<RadialController, RadialControllerScreenContactContinuedEventArgs> ScreenContactContinued;
+   TypedEventHandler<RadialController, object> ScreenContactEnded;
+   TypedEventHandler<RadialController, RadialControllerScreenContactStartedEventArgs> ScreenContactStarted;
+ }

+ public class Windows.UI.Input.RadialControllerConfiguration {
+   public void SetDefaultMenuItems( IIterable<RadialControllerSystemMenuItemKind> buttons );
+   public void ResetToDefaultMenuItems();
+   public bool TrySelectDefaultMenuItem( RadialControllerSystemMenuItemKind result );
+   public static RadialControllerConfiguration GetForCurrentView();
+ }

+ public class Windows.UI.Input.RadialControllerMenu {
+   public bool IsEnabled { get; set; }
+   public IVector<RadialControllerMenuItem> Items { get; }
+   public RadialControllerMenuItem GetSelectedMenuItem();
+   public void SelectMenuItem( RadialControllerMenuItem menuItem );
+   public bool TrySelectPreviouslySelectedMenuItem();
+ }

+ public class Windows.UI.Input.RadialControllerMenuItem {
+   public object Tag { get; set; }
+   public string DisplayText { get; }
+   public static RadialControllerMenuItem CreateFromIcon( string result, RandomAccessStreamReference displayText );
+   public static RadialControllerMenuItem CreateFromKnownIcon( string result, RadialControllerMenuKnownIcon displayText );
+   TypedEventHandler<RadialControllerMenuItem, object> Invoked;
+ }

+ public enum Windows.UI.Input.RadialControllerMenuKnownIcon {
+   Scroll = 0,
+   Zoom = 1,
+   UndoRedo = 2,
+   Volume = 3,
+   NextPreviousTrack = 4,
+   Ruler = 5,
+   InkColor = 6,
+   InkThickness = 7,
+   PenType = 8,
+ }

+ public class Windows.UI.Input.RadialControllerRotationChangedEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+   public double RotationDeltaInDegrees { get; }
+ }

+ public class Windows.UI.Input.RadialControllerScreenContact {
+   public Rect Bounds { get; }
+   public Point Position { get; }
+ }

+ public class Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+ }

+ public class Windows.UI.Input.RadialControllerScreenContactStartedEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+ }

+ public enum Windows.UI.Input.RadialControllerSystemMenuItemKind {
+   Scroll = 0,
+   Zoom = 1,
+   UndoRedo = 2,
+   Volume = 3,
+   NextPreviousTrack = 4,
+ }

+ public interface Windows.UI.Input.Inking.IInkPresenterRulerFactory {
+   public InkPresenterRuler Create( InkPresenter inkPresenterRuler );
+ }

+ public interface Windows.UI.Input.Inking.IInkPresenterStencil {
+   public Color BackgroundColor { get; set; }
+   public Color ForegroundColor { get; set; }
+   public bool IsVisible { get; set; }
+   public InkPresenterStencilKind Kind { get; }
+   public Matrix3x2 Transform { get; set; }
+ }

| public class Windows.UI.Input.Inking.InkDrawingAttributes {
+   public InkDrawingAttributesKind Kind { get; }
+   public InkDrawingAttributesPencilProperties PencilProperties { get; }
+   public static InkDrawingAttributes CreateForPencil();
| }

+ public enum Windows.UI.Input.Inking.InkDrawingAttributesKind {
+   Default = 0,
+   Pencil = 1,
+ }

+ public class Windows.UI.Input.Inking.InkDrawingAttributesPencilProperties {
+   public double Opacity { get; set; }
+ }

+ public class Windows.UI.Input.Inking.InkPresenterRuler {
+   public double Width { get; set; }
+   public double Length { get; set; }
+   public Matrix3x2 Transform { get; set; }
+   public bool IsVisible { get; set; }
+   public Color ForegroundColor { get; set; }
+   public Color BackgroundColor { get; set; }
+   public InkPresenterStencilKind Kind { get; }
+   public InkPresenterRuler( InkPresenter inkPresenter );
+ }

+ public enum Windows.UI.Input.Inking.InkPresenterStencilKind {
+   Other = 0,
+   Ruler = 1,
+ }

+ public enum Windows.UI.Input.Inking.Core.CoreWetStrokeDisposition {
+   Inking = 0,
+   Completed = 1,
+   Canceled = 2,
+ }

+ public class Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs {
+   public CoreWetStrokeDisposition Disposition { get; set; }
+   public IVector<InkPoint> NewInkPoints { get; }
+   public uint PointerId { get; }
+ }

+ public class Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource {
+   public InkPresenter InkPresenter { get; }
+   public static CoreWetStrokeUpdateSource Create( InkPresenter WetStrokeUpdateSource );
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeCanceled;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeCompleted;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeContinuing;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeStarting;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeStopping;
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputButtonChangeKind {
+   None = 0,
+   FirstButtonDown = 1,
+   FirstButtonUp = 2,
+   SecondButtonDown = 3,
+   SecondButtonUp = 4,
+   ThirdButtonDown = 5,
+   ThirdButtonUp = 6,
+   FourthButtonDown = 7,
+   FourthButtonUp = 8,
+   FifthButtonDown = 9,
+   FifthButtonUp = 10,
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputKeyOptions {
+   None = 0,
+   ExtendedKey = 1,
+   KeyUp = 2,
+   ScanCode = 8,
+   Unicode = 4,
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo {
+   public ushort VirtualKey { get; set; }
+   public ushort ScanCode { get; set; }
+   public InjectedInputKeyOptions KeyOptions { get; set; }
+   public InjectedInputKeyboardInfo();
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo {
+   public uint TimeOffsetInMilliseconds { get; set; }
+   public InjectedInputMouseOptions MouseOptions { get; set; }
+   public uint MouseData { get; set; }
+   public int DeltaY { get; set; }
+   public int DeltaX { get; set; }
+   public InjectedInputMouseInfo();
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputMouseOptions {
+   None = 0,
+   Move = 1,
+   LeftDown = 2,
+   LeftUp = 4,
+   RightDown = 8,
+   RightUp = 16,
+   MiddleDown = 32,
+   MiddleUp = 64,
+   XDown = 128,
+   XUp = 256,
+   Wheel = 2048,
+   HWheel = 4096,
+   MoveNoCoalesce = 8192,
+   VirtualDesk = 16384,
+   Absolute = 32768,
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputPenButtons {
+   None = 0,
+   Barrel = 1,
+   Inverted = 2,
+   Eraser = 4,
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputPenInfo {
+   public int TiltY { get; set; }
+   public int TiltX { get; set; }
+   public double Rotation { get; set; }
+   public double Pressure { get; set; }
+   public InjectedInputPointerInfo PointerInfo { get; set; }
+   public InjectedInputPenParameters PenParameters { get; set; }
+   public InjectedInputPenButtons PenButtons { get; set; }
+   public InjectedInputPenInfo();
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputPenParameters {
+   None = 0,
+   Pressure = 1,
+   Rotation = 2,
+   TiltX = 4,
+   TiltY = 8,
+ }

+ public struct Windows.UI.Input.Preview.Injection.InjectedInputPoint {
+   public int PositionX;
+   public int PositionY;
+ }

+ public struct Windows.UI.Input.Preview.Injection.InjectedInputPointerInfo {
+   public uint PointerId;
+   public InjectedInputPointerOptions PointerOptions;
+   public InjectedInputPoint PixelLocation;
+   public uint TimeOffsetInMilliseconds;
+   public ulong PerformanceCount;
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputPointerOptions {
+   None = 0,
+   New = 1,
+   InRange = 2,
+   InContact = 4,
+   FirstButton = 16,
+   SecondButton = 32,
+   Primary = 8192,
+   Confidence = 16384,
+   Canceled = 32768,
+   PointerDown = 65536,
+   Update = 131072,
+   PointerUp = 262144,
+   CaptureChanged = 2097152,
+ }

+ public struct Windows.UI.Input.Preview.Injection.InjectedInputRectangle {
+   public int Left;
+   public int Top;
+   public int Bottom;
+   public int Right;
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputShortcut {
+   Back = 0,
+   Start = 1,
+   Search = 2,
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo {
+   public InjectedInputTouchParameters TouchParameters { get; set; }
+   public double Pressure { get; set; }
+   public InjectedInputPointerInfo PointerInfo { get; set; }
+   public int Orientation { get; set; }
+   public InjectedInputRectangle Contact { get; set; }
+   public InjectedInputTouchInfo();
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputTouchParameters {
+   None = 0,
+   Contact = 1,
+   Orientation = 2,
+   Pressure = 4,
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputVisualizationMode {
+   None = 0,
+   Default = 1,
+   Indirect = 2,
+ }

+ public class Windows.UI.Input.Preview.Injection.InputInjector {
+   public void InjectKeyboardInput( IIterable<InjectedInputKeyboardInfo> input );
+   public void InjectMouseInput( IIterable<InjectedInputMouseInfo> input );
+   public void InitializeTouchInjection( InjectedInputVisualizationMode visualMode );
+   public void InjectTouchInput( IIterable<InjectedInputTouchInfo> input );
+   public void UninitializeTouchInjection();
+   public void InitializePenInjection( InjectedInputVisualizationMode visualMode );
+   public void InjectPenInput( InjectedInputPenInfo input );
+   public void UninitializePenInjection();
+   public void InjectShortcut( InjectedInputShortcut shortcut );
+   public static InputInjector TryCreate();
+ }

+ public enum Windows.UI.Notifications.AdaptiveNotificationContentKind {
+   Text = 0,
+ }

+ public class Windows.UI.Notifications.AdaptiveNotificationText {
+   public IMap<string, string> Hints { get; }
+   public AdaptiveNotificationContentKind Kind { get; }
+   public string Text { get; set; }
+   public string Language { get; set; }
+   public AdaptiveNotificationText();
+ }

| public class Windows.UI.Notifications.BadgeUpdateManager {
+   public static BadgeUpdateManagerForUser GetForUser( User result );
| }

+ public class Windows.UI.Notifications.BadgeUpdateManagerForUser {
+   public User User { get; }
+   public BadgeUpdater CreateBadgeUpdaterForApplication();
+   public BadgeUpdater CreateBadgeUpdaterForApplication( string result );
+   public BadgeUpdater CreateBadgeUpdaterForSecondaryTile( string result );
+ }

+ public interface Windows.UI.Notifications.IAdaptiveNotificationContent {
+   public IMap<string, string> Hints { get; }
+   public AdaptiveNotificationContentKind Kind { get; }
+ }

+ public class Windows.UI.Notifications.KnownAdaptiveNotificationHints {
+   public string Align { get; }
+   public string MaxLines { get; }
+   public string MinLines { get; }
+   public string Style { get; }
+   public string TextStacking { get; }
+   public string Wrap { get; }
+ }

+ public class Windows.UI.Notifications.KnownAdaptiveNotificationTextStyles {
+   public string Base { get; }
+   public string BaseSubtle { get; }
+   public string Body { get; }
+   public string BodySubtle { get; }
+   public string Caption { get; }
+   public string CaptionSubtle { get; }
+   public string Header { get; }
+   public string HeaderNumeral { get; }
+   public string HeaderNumeralSubtle { get; }
+   public string HeaderSubtle { get; }
+   public string Subheader { get; }
+   public string SubheaderNumeral { get; }
+   public string SubheaderNumeralSubtle { get; }
+   public string SubheaderSubtle { get; }
+   public string Subtitle { get; }
+   public string SubtitleSubtle { get; }
+   public string Title { get; }
+   public string TitleNumeral { get; }
+   public string TitleSubtle { get; }
+ }

+ public class Windows.UI.Notifications.KnownNotificationBindings {
+   public string ToastGeneric { get; }
+ }

+ public class Windows.UI.Notifications.Notification {
+   public NotificationVisual Visual { get; set; }
+   public IReference<DateTime> ExpirationTime { get; set; }
+   public NotificationKinds NotificationKinds { get; }
+   public Notification();
+ }

+ public class Windows.UI.Notifications.NotificationBinding {
+   public string Template { get; set; }
+   public string Language { get; set; }
+   public IMap<string, string> Hints { get; }
+   public IVectorView<AdaptiveNotificationText> GetTextElements();
+ }

+ public enum Windows.UI.Notifications.NotificationKinds {
+   Unknown = 0,
+   Toast = 1,
+ }

+ public enum Windows.UI.Notifications.NotificationMirroring {
+   Allowed = 0,
+   Disabled = 1,
+ }

+ public class Windows.UI.Notifications.NotificationVisual {
+   public string Language { get; set; }
+   public IVector<NotificationBinding> Bindings { get; }
+   public NotificationBinding GetBinding( string result );
+ }

+ public class Windows.UI.Notifications.ShownTileNotification {
+   public string Arguments { get; }
+ }

| public class Windows.UI.Notifications.TileUpdateManager {
+   public static TileUpdateManagerForUser GetForUser( User result );
| }

+ public class Windows.UI.Notifications.TileUpdateManagerForUser {
+   public User User { get; }
+   public TileUpdater CreateTileUpdaterForApplicationForUser();
+   public TileUpdater CreateTileUpdaterForApplication( string updater );
+   public TileUpdater CreateTileUpdaterForSecondaryTile( string updater );
+ }

| public class Windows.UI.Notifications.ToastNotification {
+   public string RemoteId { get; set; }
+   public NotificationMirroring NotificationMirroring { get; set; }
| }

| public class Windows.UI.Notifications.ToastNotificationManager {
+   public static ToastNotificationManagerForUser GetForUser( User result );
+   public static void ConfigureNotificationMirroring( NotificationMirroring value );
| }

+ public class Windows.UI.Notifications.ToastNotificationManagerForUser {
+   public ToastNotificationHistory History { get; }
+   public User User { get; }
+   public ToastNotifier CreateToastNotifier();
+   public ToastNotifier CreateToastNotifier( string result );
+ }

+ public class Windows.UI.Notifications.UserNotification {
+   public AppInfo AppInfo { get; }
+   public DateTime CreationTime { get; }
+   public uint Id { get; }
+   public Notification Notification { get; }
+ }

+ public class Windows.UI.Notifications.UserNotificationChangedEventArgs {
+   public UserNotificationChangedKind ChangeKind { get; }
+   public NotificationKinds NotificationKinds { get; }
+   public uint UserNotificationId { get; }
+ }

+ public enum Windows.UI.Notifications.UserNotificationChangedKind {
+   Added = 0,
+   Removed = 1,
+ }

+ public class Windows.UI.Notifications.Management.UserNotificationListener {
+   public UserNotificationListener Current { get; }
+   public IAsyncOperation<UserNotificationListenerAccessStatus> RequestAccessAsync();
+   public UserNotificationListenerAccessStatus GetAccessStatus();
+   public IAsyncOperation<IVectorView<UserNotification>> GetNotificationsAsync( NotificationKinds result );
+   public UserNotification GetNotification( uint result );
+   public void ClearNotifications();
+   public void RemoveNotification( uint notificationId );
+   TypedEventHandler<UserNotificationListener, UserNotificationChangedEventArgs> NotificationChanged;
+ }

+ public enum Windows.UI.Notifications.Management.UserNotificationListenerAccessStatus {
+   Unspecified = 0,
+   Allowed = 1,
+   Denied = 2,
+ }

| public enum Windows.UI.Text.Core.CoreTextInputScope {
+   ChatWithoutEmoji = 68,
| }

+ public class Windows.UI.WebUI.EnteredBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public void delegate Windows.UI.WebUI.EnteredBackgroundEventHandler( object sender, IEnteredBackgroundEventArgs e );

+ public class Windows.UI.WebUI.LeavingBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public void delegate Windows.UI.WebUI.LeavingBackgroundEventHandler( object sender, ILeavingBackgroundEventArgs e );

| public class Windows.UI.WebUI.WebUIAppointmentsProviderAddAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderRemoveAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderReplaceAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderShowTimeFrameActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUICachedFileUpdaterActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIDeviceActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIDevicePairingActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIDialReceiverActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileOpenPickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileOpenPickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileSavePickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileSavePickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFolderPickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUILaunchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUILockScreenActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIProtocolActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIProtocolForResultsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIRestrictedLaunchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIShareTargetActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIToastNotificationActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.UI.WebUI.WebUIUserDataAccountProviderActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public IUserDataAccountProviderOperation Operation { get; }
+   public ActivatedOperation ActivatedOperation { get; }
+ }

| public class Windows.UI.WebUI.WebUIVoiceCommandActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIWebAccountProviderActivatedEventArgs {
+   public User User { get; }
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.UI.Xaml.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.UI.Xaml.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.UI.Xaml.Application {
+   public ApplicationRequiresPointerMode RequiresPointerMode { get; set; }
+   public FocusVisualKind FocusVisualKind { get; set; }
| }

+ public enum Windows.UI.Xaml.ApplicationRequiresPointerMode {
+   Auto = 0,
+   WhenRequested = 1,
+ }

| public class Windows.UI.Xaml.DragEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public DataPackageOperation AllowedOperations { get; }
| }

| public class Windows.UI.Xaml.DragStartingEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public DataPackageOperation AllowedOperations { get; set; }
| }

+ public enum Windows.UI.Xaml.ElementSoundKind {
+   Focus = 0,
+   Invoke = 1,
+   Show = 2,
+   Hide = 3,
+   MovePrevious = 4,
+   MoveNext = 5,
+   GoBack = 6,
+ }

+ public enum Windows.UI.Xaml.ElementSoundMode {
+   Default = 0,
+   Off = 1,
+   FocusOnly = 2,
+ }

+ public class Windows.UI.Xaml.ElementSoundPlayer {
+   public double Volume { get; set; }
+   public ElementSoundPlayerState State { get; set; }
+   public static void Play( ElementSoundKind sound );
+ }

+ public enum Windows.UI.Xaml.ElementSoundPlayerState {
+   Auto = 0,
+   Off = 1,
+   On = 2,
+ }

+ public void delegate Windows.UI.Xaml.EnteredBackgroundEventHandler( object sender, EnteredBackgroundEventArgs e );

+ public enum Windows.UI.Xaml.FocusVisualKind {
+   DottedLine = 0,
+   HighVisibility = 1,
+ }

| public class Windows.UI.Xaml.FrameworkElement : Windows.UI.Xaml.UIElement {
+   public Thickness FocusVisualMargin { get; set; }
+   public Brush FocusVisualSecondaryBrush { get; set; }
+   public Thickness FocusVisualPrimaryThickness { get; set; }
+   public Brush FocusVisualPrimaryBrush { get; set; }
+   public bool AllowFocusWhenDisabled { get; set; }
+   public Thickness FocusVisualSecondaryThickness { get; set; }
+   public DependencyProperty AllowFocusWhenDisabledProperty { get; }
+   public DependencyProperty FocusVisualMarginProperty { get; }
+   public DependencyProperty FocusVisualPrimaryBrushProperty { get; }
+   public DependencyProperty FocusVisualPrimaryThicknessProperty { get; }
+   public DependencyProperty FocusVisualSecondaryBrushProperty { get; }
+   public DependencyProperty FocusVisualSecondaryThicknessProperty { get; }
| }

+ public void delegate Windows.UI.Xaml.LeavingBackgroundEventHandler( object sender, LeavingBackgroundEventArgs e );

| public class Windows.UI.Xaml.UIElement : Windows.UI.Xaml.DependencyObject {
+   public bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
+   public DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
| }

+ public class Windows.UI.Xaml.Automation.Peers.InkToolbarAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+ }

+ public class Windows.UI.Xaml.Automation.Peers.MediaPlayerElementAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+   public MediaPlayerElementAutomationPeer( MediaPlayerElement owner );
+ }

| public class Windows.UI.Xaml.Controls.AppBar : Windows.UI.Xaml.Controls.ContentControl {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AppBarButton : Windows.UI.Xaml.Controls.Button {
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+   public DependencyProperty DynamicOverflowOrderProperty { get; }
+   public DependencyProperty IsInOverflowProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AppBarSeparator : Windows.UI.Xaml.Controls.Control {
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+   public DependencyProperty DynamicOverflowOrderProperty { get; }
+   public DependencyProperty IsInOverflowProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AppBarToggleButton : Windows.UI.Xaml.Controls.Primitives.ToggleButton {
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+   public DependencyProperty DynamicOverflowOrderProperty { get; }
+   public DependencyProperty IsInOverflowProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AutoSuggestBox : Windows.UI.Xaml.Controls.ItemsControl {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.CalendarDatePicker : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.ColorCollection : Windows.UI.Xaml.DependencyObject {
+   public uint Size { get; }
+   public ColorCollection();
+   public object GetAt( uint returnValue );
+   public IVectorView<object> GetView();
+   public bool IndexOf( object returnValue, ref uint value );
+   public void SetAt( uint index, object value );
+   public void InsertAt( uint index, object value );
+   public void RemoveAt( uint index );
+   public void Append( object value );
+   public void RemoveAtEnd();
+   public void Clear();
+   public uint GetMany( uint returnValue, object[] startIndex );
+   public void ReplaceAll( object[] items );
+   public IIterator<object> First();
+ }

| public class Windows.UI.Xaml.Controls.ComboBox : Windows.UI.Xaml.Controls.Primitives.Selector {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public bool IsTextSearchEnabled { get; set; }
+   public DependencyProperty IsTextSearchEnabledProperty { get; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.CommandBar : Windows.UI.Xaml.Controls.AppBar {
+   public bool IsDynamicOverflowEnabled { get; set; }
+   public DependencyProperty IsDynamicOverflowEnabledProperty { get; }
| }

+ public enum Windows.UI.Xaml.Controls.CommandBarDynamicOverflowAction {
+   AddingToOverflow = 0,
+   RemovingFromOverflow = 1,
+ }

| public class Windows.UI.Xaml.Controls.Control : Windows.UI.Xaml.FrameworkElement {
+   public bool IsFocusEngaged { get; set; }
*   public RequiresPointer RequiresPointer { get; set; }
+   public bool IsFocusEngagementEnabled { get; set; }
+   public ElementSoundMode ElementSoundMode { get; set; }
+   public DependencyProperty ElementSoundModeProperty { get; }
+   public DependencyProperty IsFocusEngagedProperty { get; }
+   public DependencyProperty IsFocusEngagementEnabledProperty { get; }
+   public void RemoveFocusEngagement();
| }

| public class Windows.UI.Xaml.Controls.DatePicker : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs {
+   public CommandBarDynamicOverflowAction Action { get; }
+   public DynamicOverflowItemsChangingEventArgs();
+ }

+ public enum Windows.UI.Xaml.Controls.ExternalActorMode {
+   None = 0,
+   PenSwitcher = 1,
+   InkStrokeWidth = 2,
+   InkColor = 3,
+   Ruler = 4,
+   ExternalActorModeLast = 5,
+ }

+ public class Windows.UI.Xaml.Controls.FocusDisengagedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ }

+ public class Windows.UI.Xaml.Controls.FocusEngagedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ }

+ public interface Windows.UI.Xaml.Controls.ICommandBarElement2 {
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+ }

+ public interface Windows.UI.Xaml.Controls.IInkToolbarOverrides {
+   public void OnPenL3ColorPickerGotFocus();
+   public void OnPenL3StrokeWidthGotFocus();
+ }

+ public interface Windows.UI.Xaml.Controls.IInkToolbarPenButtonOverrides {
+   public InkDrawingAttributes CreateInkDrawingAttributes();
+ }

| public class Windows.UI.Xaml.Controls.Image : Windows.UI.Xaml.FrameworkElement {
+   public CompositionBrush GetAlphaMask();
| }

+ public class Windows.UI.Xaml.Controls.InkToolbar : Windows.UI.Xaml.Controls.Control {
+   public InkCanvas TargetInkCanvas { get; set; }
+   public bool IsRulerButtonChecked { get; set; }
+   public InkToolbarInitialControls InitialControls { get; set; }
+   public InkToolbarToolButton ActiveTool { get; set; }
+   public DependencyObjectCollection Children { get; }
+   public InkDrawingAttributes InkDrawingAttributes { get; }
+   public DependencyProperty ActiveToolProperty { get; }
+   public DependencyProperty ChildrenProperty { get; }
+   public DependencyProperty InitialControlsProperty { get; }
+   public DependencyProperty InkDrawingAttributesProperty { get; }
+   public DependencyProperty IsRulerButtonCheckedProperty { get; }
+   public DependencyProperty TargetInkCanvasProperty { get; }
+   public InkToolbar();
+   public InkToolbarToolButton GetToolButton( InkToolbarTool returnValue );
+   public InkToolbarToggleButton GetToggleButton( InkToolbarToggle returnValue );
+   TypedEventHandler<InkToolbar, object> ActiveToolChanged;
+   TypedEventHandler<InkToolbar, object> EraseAllClicked;
+   TypedEventHandler<InkToolbar, object> InkDrawingAttributesChanged;
+   TypedEventHandler<InkToolbar, object> IsRulerButtonCheckedChanged;
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarBallpointPenButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarBallpointPenButton();
+   public InkToolbarBallpointPenButton( int index );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomPen : Windows.UI.Xaml.DependencyObject {
+   protected InkToolbarCustomPen();
+   public InkDrawingAttributes CreateInkDrawingAttributes( Brush returnValue, double brush );
+   protected InkDrawingAttributes CreateInkDrawingAttributesCore( Brush returnValue, double brush );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomPenButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarCustomPen CustomPen { get; set; }
+   public UIElement ConfigurationContent { get; set; }
+   public DependencyProperty ConfigurationContentProperty { get; }
+   public DependencyProperty CustomPenProperty { get; }
+   public InkToolbarCustomPenButton();
+   public InkToolbarCustomPenButton( int index );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomToggleButton : Windows.UI.Xaml.Controls.InkToolbarToggleButton {
+   public InkToolbarCustomToggleButton();
+   public InkToolbarCustomToggleButton( int index );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomToolButton : Windows.UI.Xaml.Controls.InkToolbarToolButton {
+   public UIElement ConfigurationContent { get; set; }
+   public DependencyProperty ConfigurationContentProperty { get; }
+   public InkToolbarCustomToolButton();
+   public InkToolbarCustomToolButton( int index );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarEraserButton : Windows.UI.Xaml.Controls.InkToolbarToolButton {
+   public InkToolbarEraserButton();
+   public InkToolbarEraserButton( int index );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarHighlighterButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarHighlighterButton();
+   public InkToolbarHighlighterButton( int index );
+ }

+ public enum Windows.UI.Xaml.Controls.InkToolbarInitialControls {
+   All = 0,
+   None = 1,
+   PensOnly = 2,
+   AllExceptPens = 3,
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarPenButton : Windows.UI.Xaml.Controls.InkToolbarToolButton {
+   public double SelectedStrokeWidth { get; set; }
+   public int SelectedBrushIndex { get; set; }
+   public IVector<Brush> Palette { get; set; }
+   public double MinStrokeWidth { get; set; }
+   public double MaxStrokeWidth { get; set; }
+   public Brush SelectedBrush { get; }
+   public DependencyProperty MaxStrokeWidthProperty { get; }
+   public DependencyProperty MinStrokeWidthProperty { get; }
+   public DependencyProperty PaletteProperty { get; }
+   public DependencyProperty SelectedBrushIndexProperty { get; }
+   public DependencyProperty SelectedBrushProperty { get; }
+   public DependencyProperty SelectedStrokeWidthProperty { get; }
+   protected InkToolbarPenButton();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarPenConfigurationControl : Windows.UI.Xaml.Controls.Control {
+   public InkToolbarPenButton PenButton { get; }
+   public DependencyProperty PenButtonProperty { get; }
+   public InkToolbarPenConfigurationControl();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarPencilButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarPencilButton();
+   public InkToolbarPencilButton( int index );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarRulerButton : Windows.UI.Xaml.Controls.InkToolbarToggleButton {
+   public InkPresenterRuler Ruler { get; }
+   public DependencyProperty RulerProperty { get; }
+   public InkToolbarRulerButton();
+   public InkToolbarRulerButton( int index );
+ }

+ public enum Windows.UI.Xaml.Controls.InkToolbarToggle {
+   Ruler = 0,
+   Custom = 1,
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarToggleButton : Windows.UI.Xaml.Controls.CheckBox {
+   public InkToolbarToggle ToggleKind { get; }
+   protected InkToolbarToggleButton();
+ }

+ public enum Windows.UI.Xaml.Controls.InkToolbarTool {
+   BallpointPen = 0,
+   Pencil = 1,
+   Highlighter = 2,
+   Eraser = 3,
+   CustomPen = 4,
+   CustomTool = 5,
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarToolButton : Windows.UI.Xaml.Controls.RadioButton {
+   public bool IsExtensionGlyphShown { get; set; }
+   public InkToolbarTool ToolKind { get; }
+   public DependencyProperty IsExtensionGlyphShownProperty { get; }
+   protected InkToolbarToolButton();
+ }

+ public enum Windows.UI.Xaml.Controls.LightDismissOverlayMode {
+   Auto = 0,
+   On = 1,
+   Off = 2,
+ }

+ public class Windows.UI.Xaml.Controls.MediaPlayerElement : Windows.UI.Xaml.Controls.Control {
+   public MediaTransportControls TransportControls { get; set; }
+   public Stretch Stretch { get; set; }
+   public IMediaPlaybackSource Source { get; set; }
+   public ImageSource PosterSource { get; set; }
+   public bool IsFullWindow { get; set; }
+   public bool AutoPlay { get; set; }
+   public bool AreTransportControlsEnabled { get; set; }
+   public MediaPlayer MediaPlayer { get; }
+   public DependencyProperty AreTransportControlsEnabledProperty { get; }
+   public DependencyProperty AutoPlayProperty { get; }
+   public DependencyProperty IsFullWindowProperty { get; }
+   public DependencyProperty MediaPlayerProperty { get; }
+   public DependencyProperty PosterSourceProperty { get; }
+   public DependencyProperty SourceProperty { get; }
+   public DependencyProperty StretchProperty { get; }
+   public MediaPlayerElement();
+   public void SetMediaPlayer( MediaPlayer mediaPlayer );
+ }

+ public class Windows.UI.Xaml.Controls.MediaPlayerPresenter : Windows.UI.Xaml.FrameworkElement {
+   public Stretch Stretch { get; set; }
+   public MediaPlayer MediaPlayer { get; set; }
+   public bool IsFullWindow { get; set; }
+   public DependencyProperty IsFullWindowProperty { get; }
+   public DependencyProperty MediaPlayerProperty { get; }
+   public DependencyProperty StretchProperty { get; }
+   public MediaPlayerPresenter();
+ }

| public class Windows.UI.Xaml.Controls.MediaTransportControls : Windows.UI.Xaml.Controls.Control {
+   public bool IsSkipForwardEnabled { get; set; }
+   public FastPlayFallbackBehaviour FastPlayFallbackBehaviour { get; set; }
+   public bool IsSkipForwardButtonVisible { get; set; }
+   public bool IsSkipBackwardEnabled { get; set; }
+   public bool IsSkipBackwardButtonVisible { get; set; }
+   public bool IsPreviousTrackButtonVisible { get; set; }
+   public bool IsNextTrackButtonVisible { get; set; }
+   public DependencyProperty FastPlayFallbackBehaviourProperty { get; }
+   public DependencyProperty IsNextTrackButtonVisibleProperty { get; }
+   public DependencyProperty IsPreviousTrackButtonVisibleProperty { get; }
+   public DependencyProperty IsSkipBackwardButtonVisibleProperty { get; }
+   public DependencyProperty IsSkipBackwardEnabledProperty { get; }
+   public DependencyProperty IsSkipForwardButtonVisibleProperty { get; }
+   public DependencyProperty IsSkipForwardEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.Pivot : Windows.UI.Xaml.Controls.ItemsControl {
+   public bool IsHeaderItemsCarouselEnabled { get; set; }
+   public PivotHeaderFocusVisualPlacement HeaderFocusVisualPlacement { get; set; }
+   public DependencyProperty IsHeaderItemsCarouselEnabledProperty { get; }
+   public DependencyProperty HeaderFocusVisualPlacementProperty { get; }
-   public PivotHeaderOverflowMode HeaderOverflowMode { get; set; }
-   public DependencyProperty HeaderOverflowModeProperty { get; }
| }

+ public enum Windows.UI.Xaml.Controls.PivotHeaderFocusVisualPlacement {
+   ItemHeaders = 0,
+   SelectedItemHeader = 1,
+ }

- public enum Windows.UI.Xaml.Controls.PivotHeaderOverflowMode;

+ public enum Windows.UI.Xaml.Controls.RequiresPointer {
+   Never = 0,
+   WhenEngaged = 1,
+   WhenFocused = 2,
+ }

- public enum Windows.UI.Xaml.Controls.RequiresPointerMode;

| public class Windows.UI.Xaml.Controls.SplitView : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.TextBlock : Windows.UI.Xaml.FrameworkElement {
+   public CompositionBrush GetAlphaMask();
| }

| public class Windows.UI.Xaml.Controls.TimePicker : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public enum Windows.UI.Xaml.Controls.WebViewPermissionType {
+   WebNotifications = 4,
| }

| public class Windows.UI.Xaml.Controls.Primitives.FlyoutBase : Windows.UI.Xaml.DependencyObject {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public ElementSoundMode ElementSoundMode { get; set; }
+   public bool AllowFocusWhenDisabled { get; set; }
+   public DependencyProperty AllowFocusWhenDisabledProperty { get; }
+   public DependencyProperty ElementSoundModeProperty { get; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.Primitives.Popup : Windows.UI.Xaml.FrameworkElement {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Documents.Hyperlink : Windows.UI.Xaml.Documents.Span {
+   public ElementSoundMode ElementSoundMode { get; set; }
+   public DependencyProperty ElementSoundModeProperty { get; }
| }

| public class Windows.UI.Xaml.Documents.TextElement : Windows.UI.Xaml.DependencyObject {
+   public bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
+   public DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
| }

| public enum Windows.UI.Xaml.Input.InputScopeNameValue {
+   ChatWithoutEmoji = 68,
| }

| public class Windows.UI.Xaml.Input.KeyRoutedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public ulong DeviceId { get; }
| }

+ public class Windows.UI.Xaml.Media.BrushCollection {
+   public uint Size { get; }
+   public BrushCollection();
+   public Brush GetAt( uint returnValue );
+   public IVectorView<Brush> GetView();
+   public bool IndexOf( Brush returnValue, ref uint value );
+   public void SetAt( uint index, Brush value );
+   public void InsertAt( uint index, Brush value );
+   public void RemoveAt( uint index );
+   public void Append( Brush value );
+   public void RemoveAtEnd();
+   public void Clear();
+   public uint GetMany( uint returnValue, Brush[] startIndex );
+   public void ReplaceAll( Brush[] items );
+   public IIterator<Brush> First();
+ }

+ public enum Windows.UI.Xaml.Media.FastPlayFallbackBehaviour {
+   Skip = 0,
+   Hide = 1,
+   Disable = 2,
+ }

+ public class Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs {
+   public void SetThumbnailImage( IInputStream source );
+   public Deferral GetDeferral();
+ }

+ public class Windows.UI.Xaml.Media.Animation.ConnectedAnimation {
+   public bool TryStart( UIElement returnValue );
+   public void Cancel();
+   TypedEventHandler<ConnectedAnimation, object> Completed;
+ }

+ public class Windows.UI.Xaml.Media.Animation.ConnectedAnimationService {
+   public CompositionEasingFunction DefaultEasingFunction { get; set; }
+   public TimeSpan DefaultDuration { get; set; }
+   public ConnectedAnimation PrepareToAnimate( string returnValue, UIElement key );
+   public ConnectedAnimation GetAnimation( string returnValue );
+   public static ConnectedAnimationService GetForCurrentView();
+ }

| public class Windows.UI.Xaml.Shapes.Shape : Windows.UI.Xaml.FrameworkElement {
+   public CompositionBrush GetAlphaMask();
| }


 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new file: \wim\14316x64\Windows\System32\WinMetadata\Windows.Web.winmd
 old file: \wim\14291x64\Windows\System32\WinMetadata\Windows.Web.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

 found no differences.