API changes, Windows 8.1 Update and Windows 10

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

 new file: Windows 10/Windows.ApplicationModel.winmd
 old file: Windows 8.1 Update/Windows.ApplicationModel.winmd

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

| public class Windows.ApplicationModel.Package {
+ 	public DateTime InstalledDate { get; }
+ 	public PackageStatus Status { get; }
| }

+ public class Windows.ApplicationModel.PackageStatus {
+ 	public bool DataOffline { get; }
+ 	public bool DependencyIssue { get; }
+ 	public bool DeploymentInProgress { get; }
+ 	public bool Disabled { get; }
+ 	public bool LicenseIssue { get; }
+ 	public bool Modified { get; }
+ 	public bool NeedsRemediation { get; }
+ 	public bool NotAvailable { get; }
+ 	public bool PackageOffline { get; }
+ 	public bool Servicing { get; }
+ 	public bool Tampered { get; }
+ 	public bool VerifyIsOK();
+ }

| public enum Windows.ApplicationModel.Activation.ActivationKind {
+ 	PickFileContinuation = 1002,
+ 	PickSaveFileContinuation = 1003,
+ 	PickFolderContinuation = 1004,
+ 	WebAccountProvider = 1006,
+ 	WebAccountProviderContinuation = 1007,
| }

+ public class Windows.ApplicationModel.Activation.FileOpenPickerContinuationEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public IVectorView<StorageFile> Files { get; }
+ }

+ public class Windows.ApplicationModel.Activation.FileSavePickerContinuationEventArgs {
+ 	public ValueSet ContinuationData { get; }
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public StorageFile File { get; }
+ }

+ public class Windows.ApplicationModel.Activation.FolderPickerContinuationEventArgs {
+ 	public StorageFolder Folder { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs {
+ 	public ValueSet ContinuationData { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IFileOpenPickerContinuationEventArgs {
+ 	public IVectorView<StorageFile> Files { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IFileSavePickerContinuationEventArgs {
+ 	public StorageFile File { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IFolderPickerContinuationEventArgs {
+ 	public StorageFolder Folder { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IWebAccountProviderActivatedEventArgs {
+ 	public WebAccountProviderOperation Operation { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IWebAccountProviderContinuationEventArgs {
+ 	public WebTokenRequestResult Result { get; }
+ }

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

+ public class Windows.ApplicationModel.Activation.WebAccountProviderContinuationEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public WebTokenRequestResult Result { get; }
+ }

| public class Windows.ApplicationModel.Appointments.Appointment {
+ 	public AppointmentParticipantResponse UserResponse { get; set; }
+ 	public string RoamingId { get; set; }
+ 	public IReference<DateTime> ReplyTime { get; set; }
+ 	public string OnlineMeetingLink { get; set; }
+ 	public bool IsResponseRequested { get; set; }
+ 	public bool IsOrganizedByUser { get; set; }
+ 	public bool IsCanceledMeeting { get; set; }
+ 	public bool AllowNewTimeProposal { get; set; }
+ 	public string CalendarId { get; }
+ 	public bool HasInvitees { get; }
+ 	public string LocalId { get; }
+ 	public IReference<DateTime> OriginalStartTime { get; }
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentCalendar {
+ 	public AppointmentSummaryCardView SummaryCardView { get; set; }
+ 	public AppointmentCalendarOtherAppWriteAccess OtherAppWriteAccess { get; set; }
+ 	public AppointmentCalendarOtherAppReadAccess OtherAppReadAccess { get; set; }
+ 	public string DisplayName { get; set; }
+ 	public Color DisplayColor { get; }
+ 	public bool IsHidden { get; }
+ 	public string LocalId { get; }
+ 	public string SourceDisplayName { get; }
+ 	public IAsyncOperation<IVectorView<Appointment>> FindAppointmentsAsync( DateTime result, TimeSpan rangeStart );
+ 	public IAsyncOperation<IVectorView<Appointment>> FindAppointmentsAsync( DateTime result, TimeSpan rangeStart, FindAppointmentsOptions rangeLength );
+ 	public IAsyncOperation<IVectorView<AppointmentException>> FindExceptionsFromMasterAsync( string value );
+ 	public IAsyncOperation<IVectorView<Appointment>> FindAllInstancesAsync( string value, DateTime masterLocalId, TimeSpan rangeStart );
+ 	public IAsyncOperation<IVectorView<Appointment>> FindAllInstancesAsync( string value, DateTime masterLocalId, TimeSpan rangeStart, FindAppointmentsOptions rangeLength );
+ 	public IAsyncOperation<Appointment> GetAppointmentAsync( string result );
+ 	public IAsyncOperation<Appointment> GetAppointmentInstanceAsync( string result, DateTime localId );
+ 	public IAsyncOperation<IVectorView<Appointment>> FindUnexpandedAppointmentsAsync();
+ 	public IAsyncOperation<IVectorView<Appointment>> FindUnexpandedAppointmentsAsync( FindAppointmentsOptions result );
+ 	public IAsyncAction DeleteAsync();
+ 	public IAsyncAction SaveAsync();
+ 	public IAsyncAction DeleteAppointmentAsync( string asyncAction );
+ 	public IAsyncAction DeleteAppointmentInstanceAsync( string asyncAction, DateTime localId );
+ 	public IAsyncAction SaveAppointmentAsync( Appointment asyncAction );
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentCalendarOtherAppReadAccess {
+ 	SystemOnly = 0,
+ 	Limited = 1,
+ 	Full = 2,
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentCalendarOtherAppWriteAccess {
+ 	None = 0,
+ 	SystemOnly = 1,
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentConflictResult {
+ 	public DateTime Date { get; }
+ 	public AppointmentConflictType Type { get; }
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentConflictType {
+ 	None = 0,
+ 	Adjacent = 1,
+ 	Overlap = 2,
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentException {
+ 	public Appointment Appointment { get; }
+ 	public IVectorView<string> ExceptionProperties { get; }
+ 	public bool IsDeleted { get; }
+ }

| public class Windows.ApplicationModel.Appointments.AppointmentManager {
+ 	public static IAsyncAction ShowAppointmentDetailsAsync( string asyncAction );
+ 	public static IAsyncAction ShowAppointmentDetailsAsync( string asyncAction, DateTime appointmentId );
+ 	public static IAsyncOperation<string> ShowEditNewAppointmentAsync( Appointment operation );
+ 	public static IAsyncOperation<AppointmentStore> RequestStoreAsync( AppointmentStoreAccessType operation );
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentProperties {
+ 	public string AllDay { get; }
+ 	public string AllowNewTimeProposal { get; }
+ 	public string BusyStatus { get; }
+ 	public IVector<string> DefaultProperties { get; }
+ 	public string Details { get; }
+ 	public string HasInvitees { get; }
+ 	public string Invitees { get; }
+ 	public string IsCanceledMeeting { get; }
+ 	public string IsOrganizedByUser { get; }
+ 	public string IsResponseRequested { get; }
+ 	public string Location { get; }
+ 	public string OnlineMeetingLink { get; }
+ 	public string Organizer { get; }
+ 	public string OriginalStartTime { get; }
+ 	public string Recurrence { get; }
+ 	public string Reminder { get; }
+ 	public string ReplyTime { get; }
+ 	public string StartTime { get; }
+ 	public string Subject { get; }
+ 	public string Uri { get; }
+ 	public string UserResponse { get; }
+ 	public string Duration { get; }
+ 	public string Sensitivity { get; }
+ }

| public class Windows.ApplicationModel.Appointments.AppointmentRecurrence {
+ 	public string TimeZone { get; set; }
+ 	public RecurrenceType RecurrenceType { get; }
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentStore {
+ 	public AppointmentStoreChangeTracker ChangeTracker { get; }
+ 	public IAsyncOperation<AppointmentCalendar> CreateAppointmentCalendarAsync( string operation );
+ 	public IAsyncOperation<AppointmentCalendar> GetAppointmentCalendarAsync( string result );
+ 	public IAsyncOperation<Appointment> GetAppointmentAsync( string result );
+ 	public IAsyncOperation<Appointment> GetAppointmentInstanceAsync( string result, DateTime localId );
+ 	public IAsyncOperation<IVectorView<AppointmentCalendar>> FindAppointmentCalendarsAsync();
+ 	public IAsyncOperation<IVectorView<AppointmentCalendar>> FindAppointmentCalendarsAsync( FindAppointmentCalendarsOptions result );
+ 	public IAsyncOperation<IVectorView<Appointment>> FindAppointmentsAsync( DateTime result, TimeSpan rangeStart );
+ 	public IAsyncOperation<IVectorView<Appointment>> FindAppointmentsAsync( DateTime result, TimeSpan rangeStart, FindAppointmentsOptions rangeLength );
+ 	public IAsyncOperation<AppointmentConflictResult> FindConflictAsync( Appointment result );
+ 	public IAsyncOperation<AppointmentConflictResult> FindConflictAsync( Appointment result, DateTime appointment );
+ 	public IAsyncAction MoveAppointmentAsync( Appointment asyncAction, AppointmentCalendar appointment );
+ 	public IAsyncOperation<string> ShowAddAppointmentAsync( Appointment operation, Rect appointment );
+ 	public IAsyncOperation<string> ShowReplaceAppointmentAsync( string operation, Appointment localId, Rect appointment );
+ 	public IAsyncOperation<string> ShowReplaceAppointmentAsync( string operation, Appointment localId, Rect appointment, Placement selection, DateTime preferredPlacement );
+ 	public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string operation, Rect localId );
+ 	public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string operation, Rect localId, Placement selection, DateTime preferredPlacement );
+ 	public IAsyncAction ShowAppointmentDetailsAsync( string asyncAction );
+ 	public IAsyncAction ShowAppointmentDetailsAsync( string asyncAction, DateTime localId );
+ 	public IAsyncOperation<string> ShowEditNewAppointmentAsync( Appointment operation );
+ 	public IAsyncOperation<IVectorView<string>> FindLocalIdsFromRoamingIdAsync( string operation );
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentStoreAccessType {
+ 	AppCalendarsReadWrite = 0,
+ 	AllCalendarsReadOnly = 1,
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentStoreChange {
+ 	public Appointment Appointment { get; }
+ 	public AppointmentStoreChangeType ChangeType { get; }
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentStoreChangeReader {
+ 	public IAsyncOperation<IVectorView<AppointmentStoreChange>> ReadBatchAsync();
+ 	public void AcceptChanges();
+ 	public void AcceptChangesThrough( AppointmentStoreChange lastChangeToAccept );
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentStoreChangeTracker {
+ 	public AppointmentStoreChangeReader GetChangeReader();
+ 	public void Enable();
+ 	public void Reset();
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentStoreChangeType {
+ 	AppointmentCreated = 0,
+ 	AppointmentModified = 1,
+ 	AppointmentDeleted = 2,
+ 	ChangeTrackingLost = 3,
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentSummaryCardView {
+ 	System = 0,
+ 	App = 1,
+ }

+ public enum Windows.ApplicationModel.Appointments.FindAppointmentCalendarsOptions {
+ 	None = 0,
+ 	IncludeHidden = 1,
+ }

+ public class Windows.ApplicationModel.Appointments.FindAppointmentsOptions {
+ 	public uint MaxCount { get; set; }
+ 	public bool IncludeHidden { get; set; }
+ 	public IVector<string> CalendarIds { get; }
+ 	public IVector<string> FetchProperties { get; }
+ 	public FindAppointmentsOptions();
+ }

+ public enum Windows.ApplicationModel.Appointments.RecurrenceType {
+ 	Master = 0,
+ 	Instance = 1,
+ 	ExceptionInstance = 2,
+ }

+ public class Windows.ApplicationModel.Background.ActivitySensorTrigger {
+ 	public uint MinimumReportInterval { get; }
+ 	public uint ReportInterval { get; }
+ 	public IVector<ActivityType> SubscribedActivities { get; }
+ 	public IVectorView<ActivityType> SupportedActivities { get; }
+ 	public ActivitySensorTrigger( uint reportIntervalInMilliseconds );
+ }

| public class Windows.ApplicationModel.Background.BackgroundTaskBuilder {
+ 	public bool IsNetworkRequested { get; set; }
| }

| public class Windows.ApplicationModel.Background.BackgroundTaskRegistration {
+ 	public IBackgroundTrigger Trigger { get; }
| }

+ public class Windows.ApplicationModel.Background.DirectActivationDetails {
+ 	public PropertySet Arguments { get; }
+ }

+ public enum Windows.ApplicationModel.Background.DirectActivationResult {
+ 	Allowed = 0,
+ 	CurrentlyRunning = 1,
+ 	DisabledByPolicy = 2,
+ 	UnknownError = 3,
+ }

+ public interface Windows.ApplicationModel.Background.IBackgroundTaskRegistration2 {
+ 	public IBackgroundTrigger Trigger { get; }
+ }

+ public class Windows.ApplicationModel.Background.MediaProcessingTrigger {
+ 	public MediaProcessingTrigger();
+ 	public IAsyncOperation<MediaProcessingTriggerResult> RequestAsync();
+ 	public IAsyncOperation<MediaProcessingTriggerResult> RequestAsync( ValueSet result );
+ }

+ public class Windows.ApplicationModel.Background.MediaProcessingTriggerDetails {
+ 	public ValueSet Arguments { get; }
+ }

+ public enum Windows.ApplicationModel.Background.MediaProcessingTriggerResult {
+ 	Allowed = 0,
+ 	CurrentlyRunning = 1,
+ 	DisabledByPolicy = 2,
+ 	UnknownError = 3,
+ }

+ public class Windows.ApplicationModel.Background.SmsMessageReceivedTrigger {
+ 	public SmsMessageReceivedTrigger( SmsFilterRules filterRules );
+ }

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

| public class Windows.ApplicationModel.Contacts.Contact {
+ 	public string RemoteId { get; set; }
+ 	public IRandomAccessStreamReference RingTone { get; set; }
+ 	public IRandomAccessStreamReference SourceDisplayPicture { get; set; }
+ 	public DateTime CurrentDisplayPictureUserUpdateTime { get; set; }
+ 	public bool IsMe { get; set; }
+ 	public IRandomAccessStreamReference TextTone { get; set; }
+ 	public bool DisplayPictureIsManuallySet { get; }
+ 	public string AggregateId { get; }
+ 	public IRandomAccessStreamReference SmallDisplayPicture { get; }
+ 	public IRandomAccessStreamReference LargeDisplayPicture { get; }
+ 	public ContactKind Kind { get; }
| }

+ public class Windows.ApplicationModel.Contacts.ContactAccount {
+ 	public ContactSyncFieldMaxCount SyncFieldMaxCount { get; set; }
+ 	public ContactStoreOtherAppWriteAccess OtherAppWriteAccess { get; set; }
+ 	public ContactStoreOtherAppReadAccess OtherAppReadAccess { get; set; }
+ 	public bool IsHidden { get; set; }
+ 	public string AccountName { get; set; }
+ 	public string AccountId { get; }
+ 	public ContactChangeTracker ContactChangeTracker { get; }
+ 	public IAsyncAction SaveAsync();
+ 	public IAsyncAction DeleteAsync();
+ 	public IAsyncOperation<Contact> GetContactFromRemoteIdAsync( string contact );
+ 	public IAsyncOperation<Contact> GetMeContactAsync();
+ 	public IAsyncOperation<ContactReader> GetContactReaderAsync();
+ 	public IAsyncOperation<ContactReader> GetContactReaderAsync( ContactReaderOptions value );
+ 	public IAsyncAction SaveContactAsync( Contact value );
+ 	public IAsyncAction DeleteContactAsync( string value );
+ 	public IAsyncOperation<Contact> GetContactAsync( string contacts );
+ 	TypedEventHandler<ContactAccount, ContactChangedEventArgs> ContactChanged;
+ }

+ public class Windows.ApplicationModel.Contacts.ContactChange {
+ 	public ContactChangeType ChangeType { get; }
+ 	public Contact Contact { get; }
+ }

+ public class Windows.ApplicationModel.Contacts.ContactChangeReader {
+ 	public void AcceptChanges();
+ 	public void AcceptChangesThrough( ContactChange lastChangeToAcknowledge );
+ 	public IAsyncOperation<IVectorView<ContactChange>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.Contacts.ContactChangeTracker {
+ 	public void Enable();
+ 	public ContactChangeReader GetChangeReader();
+ 	public void Reset();
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactChangeType {
+ 	ContactCreated = 0,
+ 	ContactModified = 1,
+ 	ContactDeleted = 2,
+ 	ChangeTrackingLost = 3,
+ }

+ public class Windows.ApplicationModel.Contacts.ContactChangedDeferral {
+ 	public ContactChangedDeferral();
+ 	public void Complete();
+ }

+ public class Windows.ApplicationModel.Contacts.ContactChangedEventArgs {
+ 	public ContactChangedEventArgs();
+ 	public ContactChangedDeferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Contacts.ContactGroup {
+ 	public ContactGroupKind Kind { get; set; }
+ 	public string DisplayName { get; set; }
+ 	public string Id { get; }
+ 	public IVector<string> MemberIds { get; }
+ 	public ContactGroup();
+ }

+ public class Windows.ApplicationModel.Contacts.ContactGroupChange {
+ 	public ContactGroupChangeType ChangeType { get; }
+ 	public ContactGroup ContactGroup { get; }
+ }

+ public class Windows.ApplicationModel.Contacts.ContactGroupChangeReader {
+ 	public void AcceptChanges();
+ 	public void AcceptChangesThrough( ContactGroupChange lastChangeToAcknowledge );
+ 	public IAsyncOperation<IVectorView<ContactGroupChange>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.Contacts.ContactGroupChangeTracker {
+ 	public void Enable();
+ 	public ContactGroupChangeReader GetChangeReader();
+ 	public void Reset();
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactGroupChangeType {
+ 	ContactGroupCreated = 0,
+ 	ContactGroupModified = 1,
+ 	ContactGroupDeleted = 2,
+ 	ChangeTrackingLost = 3,
+ }

+ public class Windows.ApplicationModel.Contacts.ContactGroupChangedDeferral {
+ 	public ContactGroupChangedDeferral();
+ 	public void Complete();
+ }

+ public class Windows.ApplicationModel.Contacts.ContactGroupChangedEventArgs {
+ 	public ContactGroupChangedEventArgs();
+ 	public ContactGroupChangedDeferral GetDeferral();
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactGroupKind {
+ 	Default = 0,
+ 	Room = 1,
+ 	SpeedDial = 2,
+ 	Custom = 65535,
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactKind {
+ 	Component = 0,
+ 	Aggregate = 1,
+ }

| public class Windows.ApplicationModel.Contacts.ContactManager {
+ 	public static IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact vCard );
+ 	public static IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact vCard, uint contact );
+ 	public static IAsyncOperation<Contact> ConvertVCardToContactAsync( RandomAccessStreamReference contact );
+ 	public static IAsyncOperation<ContactStore> RequestStoreAsync( ContactStoreAccessType store );
+ 	public static IAsyncOperation<ContactStore> RequestStoreAsync();
| }

| public class Windows.ApplicationModel.Contacts.ContactPhone {
+ 	public bool IsSkypable { get; set; }
| }

+ public class Windows.ApplicationModel.Contacts.ContactReader {
+ 	public IAsyncOperation<IVectorView<Contact>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.Contacts.ContactReaderOptions {
+ 	public string SearchText { get; set; }
+ 	public ContactReaderSearchFields SearchFields { get; set; }
+ 	public ContactReaderRequiredFields RequiredFields { get; set; }
+ 	public bool OnlyLoadDisplayProperties { get; set; }
+ 	public bool IncludeHidden { get; set; }
+ 	public IVector<string> AccountIds { get; }
+ 	public ContactReaderOptions();
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactReaderRequiredFields {
+ 	NoneRequired = 0,
+ 	PhoneNumberRequired = 1,
+ 	EmailAddressRequired = 2,
+ 	PostalAddressRequired = 4,
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactReaderSearchFields {
+ 	Name = 1,
+ 	Email = 2,
+ 	Phone = 4,
+ 	All = 65535,
+ }

| public class Windows.ApplicationModel.Contacts.ContactSignificantOther {
+ 	public ContactSignificantOtherKind Kind { get; set; }
| }

+ public enum Windows.ApplicationModel.Contacts.ContactSignificantOtherKind {
+ 	Spouse = 1,
+ 	Partner = 2,
+ 	Sibling = 3,
+ 	Parent = 4,
+ 	Child = 5,
+ 	Other = 6,
+ }

+ public class Windows.ApplicationModel.Contacts.ContactStore {
+ 	public ContactChangeTracker ContactChangeTracker { get; }
+ 	public ContactGroupChangeTracker ContactGroupChangeTracker { get; }
+ 	public IAsyncOperation<IVectorView<Contact>> FindContactsAsync();
+ 	public IAsyncOperation<IVectorView<Contact>> FindContactsAsync( string contacts );
+ 	public IAsyncOperation<Contact> GetContactAsync( string contacts );
+ 	public IAsyncOperation<IVectorView<Contact>> FindComponentsAsync( string value );
+ 	public IAsyncAction LinkAggregateContactsAsync( string value, string primaryAggregateContactId );
+ 	public IAsyncAction UnlinkFromAggregateContactAsync( string value, string aggregateContactId );
+ 	public IAsyncOperation<IVectorView<ContactAccount>> FindContactAccountsAsync();
+ 	public IAsyncOperation<ContactAccount> GetContactAccountAsync( string value );
+ 	public IAsyncOperation<ContactAccount> CreateContactAccountAsync( string value );
+ 	public IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
+ 	public IAsyncOperation<ContactGroup> GetContactGroupAsync( string value );
+ 	public IAsyncAction SaveContactGroupAsync( ContactGroup value );
+ 	public IAsyncAction DeleteContactGroupAsync( string value );
+ 	public IAsyncOperation<Contact> GetMeAggregateContactAsync();
+ 	public IAsyncOperation<ContactReader> GetContactReaderAsync();
+ 	public IAsyncOperation<ContactReader> GetContactReaderAsync( ContactReaderOptions value );
+ 	public IAsyncAction SaveAggregateContactAsync( Contact value );
+ 	TypedEventHandler<ContactStore, ContactChangedEventArgs> ContactChanged;
+ 	TypedEventHandler<ContactStore, ContactGroupChangedEventArgs> ContactGroupChanged;
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactStoreAccessType {
+ 	AppContactsReadWrite = 0,
+ 	AllContactsReadOnly = 1,
+ 	AllContactsReadWrite = 2,
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactStoreOtherAppReadAccess {
+ 	SystemOnly = 0,
+ 	Limited = 1,
+ 	Full = 2,
+ }

+ public enum Windows.ApplicationModel.Contacts.ContactStoreOtherAppWriteAccess {
+ 	None = 0,
+ 	SystemOnly = 1,
+ }

+ public struct Windows.ApplicationModel.Contacts.ContactSyncFieldMaxCount {
+ 	public bool SupportsDestription;
+ 	public bool UseFirstNameOnly;
+ 	public uint MaxHomePhone;
+ 	public uint MaxWorkPhone;
+ 	public uint MaxMobilePhone;
+ 	public uint MaxCompanyPhone;
+ 	public uint MaxPagerPhone;
+ 	public uint MaxHomeFaxPhone;
+ 	public uint MaxWorkFaxPhone;
+ 	public uint MaxHomeEmail;
+ 	public uint MaxWorkEmail;
+ 	public uint MaxOtherEmail;
+ 	public uint MaxHomeAddress;
+ 	public uint MaxWorkAddress;
+ 	public uint MaxOtherAddress;
+ 	public uint MaxWebsite;
+ 	public uint MaxParent;
+ 	public uint MaxChildren;
+ 	public uint MaxSiblings;
+ }

+ public class Windows.ApplicationModel.Core.RestrictedAppContainer {
+ 	public RestrictedAppContainerCapabilities Capabilities { get; }
+ 	public string Name { get; }
+ 	public IAsyncAction LaunchAsync( object operation );
+ 	public void TerminateAll();
+ 	public static IAsyncOperation<RestrictedAppContainer> CreateAsync( string operation, RestrictedAppContainerCapabilities name );
+ 	public static IAsyncAction DeleteAsync( string operation );
+ 	public static RestrictedAppContainer Open( string restrictedAppContainer );
+ 	public static IAsyncOperation<IVectorView<RestrictedAppContainer>> FindAllAsync();
+ }

+ public enum Windows.ApplicationModel.Core.RestrictedAppContainerCapabilities {
+ 	None = 0,
+ 	InternetClient = 1,
+ 	InternetClientServer = 2,
+ 	PrivateNetworkClientServer = 4,
+ }

+ public enum Windows.ApplicationModel.DataTransfer.DragDrop.DragDropModifiers {
+ 	None = 0,
+ 	Shift = 1,
+ 	Control = 2,
+ 	Alt = 4,
+ 	LeftButton = 8,
+ 	MiddleButton = 16,
+ 	RightButton = 32,
+ }

+ public class Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager {
+ 	public bool AreConcurrentOperationsEnabled { get; set; }
+ 	public CoreDragDropScope AllowDropFrom { get; set; }
+ 	public CoreDragDropScope AllowDragTo { get; set; }
+ 	public static CoreDragDropManager GetForCurrentView();
+ 	TypedEventHandler<CoreDragDropManager, CoreDropOperationTargetRequestedEventArgs> TargetRequested;
+ }

+ public enum Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropScope {
+ 	All = 0,
+ 	Publisher = 1,
+ 	Package = 2,
+ 	App = 3,
+ }

+ public class Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragInfo {
+ 	public DataPackageView Data { get; }
+ 	public DragDropModifiers Modifiers { get; }
+ 	public Point Position { get; }
+ }

+ public class Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragOperation {
+ 	public DataPackage Data { get; }
+ 	public IVector<uint> PointerIds { get; }
+ 	public CoreDragOperation();
+ 	public void SetDragUI( object dragContent, Size contentSize, Point anchorPoint );
+ 	public IAsyncOperation<DataPackageOperation> StartAsync();
+ }

+ public class Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragUI {
+ 	public CoreDragUIOptions Options { get; set; }
+ 	public void SetContent( object dragContent, IReference<Size> contentSize );
+ }

+ public enum Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragUIOptions {
+ 	None = 0,
+ 	SupressAdornments = 1,
+ }

+ public class Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs {
+ 	public void SetTarget( ICoreDropOperationTarget target );
+ }

+ public interface Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDropOperationTarget {
+ 	public IAsyncOperation<DataPackageOperation> EnterAsync( CoreDragInfo returnValue, CoreDragUI dragInfo );
+ 	public IAsyncOperation<DataPackageOperation> OverAsync( CoreDragInfo returnValue, CoreDragUI dragInfo );
+ 	public IAsyncAction LeaveAsync( CoreDragInfo returnValue );
+ 	public IAsyncOperation<DataPackageOperation> DropAsync( CoreDragInfo returnValue );
+ }

+ public class Windows.ApplicationModel.Email.EmailAttachment {
+ 	public string FileName { get; set; }
+ 	public IRandomAccessStreamReference Data { get; set; }
+ 	public EmailAttachment( string fileName, IRandomAccessStreamReference data );
+ 	public EmailAttachment();
+ }

+ public class Windows.ApplicationModel.Email.EmailManager {
+ 	public static IAsyncAction ShowComposeNewEmailAsync( EmailMessage asyncAction );
+ }

+ public class Windows.ApplicationModel.Email.EmailMessage {
+ 	public string Subject { get; set; }
+ 	public string Body { get; set; }
+ 	public IVector<EmailAttachment> Attachments { get; }
+ 	public IVector<EmailRecipient> Bcc { get; }
+ 	public IVector<EmailRecipient> CC { get; }
+ 	public IVector<EmailRecipient> To { get; }
+ 	public EmailMessage();
+ }

+ public class Windows.ApplicationModel.Email.EmailRecipient {
+ 	public string Name { get; set; }
+ 	public string Address { get; set; }
+ 	public EmailRecipient( string address );
+ 	public EmailRecipient( string address, string name );
+ 	public EmailRecipient();
+ }


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

 new file: Windows 10/Windows.Data.winmd
 old file: Windows 8.1 Update/Windows.Data.winmd

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

| public class Windows.Data.Json.JsonArray {
+ 	public string ToString();
| }

| public class Windows.Data.Json.JsonObject {
+ 	public string ToString();
| }

| public class Windows.Data.Json.JsonValue {
+ 	public string ToString();
+ 	public static JsonValue CreateNullValue();
| }


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

 new file: Windows 10/Windows.Devices.winmd
 old file: Windows 8.1 Update/Windows.Devices.winmd

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

+ public class Windows.Devices.Bluetooth.BluetoothClassOfDevice {
+ 	public BluetoothMajorClass MajorClass { get; }
+ 	public BluetoothMinorClass MinorClass { get; }
+ 	public uint RawValue { get; }
+ 	public BluetoothServiceCapabilities ServiceCapabilities { get; }
+ 	public static BluetoothClassOfDevice FromRawValue( uint classOfDevice );
+ 	public static BluetoothClassOfDevice FromParts( BluetoothMajorClass classOfDevice, BluetoothMinorClass majorClass, BluetoothServiceCapabilities minorClass );
+ }

+ public enum Windows.Devices.Bluetooth.BluetoothConnectionStatus {
+ 	Disconnected = 0,
+ 	Connected = 1,
+ }

+ public class Windows.Devices.Bluetooth.BluetoothDevice {
+ 	public ulong BluetoothAddress { get; }
+ 	public BluetoothClassOfDevice ClassOfDevice { get; }
+ 	public BluetoothConnectionStatus ConnectionStatus { get; }
+ 	public string DeviceId { get; }
+ 	public HostName HostName { get; }
+ 	public string Name { get; }
+ 	public IVectorView<RfcommDeviceService> RfcommServices { get; }
+ 	public IVectorView<IBuffer> SdpRecords { get; }
+ 	public static IAsyncOperation<BluetoothDevice> FromIdAsync( string operation );
+ 	public static IAsyncOperation<BluetoothDevice> FromHostNameAsync( HostName operation );
+ 	public static IAsyncOperation<BluetoothDevice> FromBluetoothAddressAsync( ulong operation );
+ 	public static string GetDeviceSelector();
+ 	TypedEventHandler<BluetoothDevice, object> ConnectionStatusChanged;
+ 	TypedEventHandler<BluetoothDevice, object> NameChanged;
+ 	TypedEventHandler<BluetoothDevice, object> SdpRecordsChanged;
+ }

+ public enum Windows.Devices.Bluetooth.BluetoothError {
+ 	Success = 0,
+ 	RadioNotAvailable = 1,
+ 	ResourceInUse = 2,
+ }

+ public class Windows.Devices.Bluetooth.BluetoothLEDevice {
+ 	public ulong BluetoothAddress { get; }
+ 	public BluetoothConnectionStatus ConnectionStatus { get; }
+ 	public string DeviceId { get; }
+ 	public IVectorView<GattDeviceService> GattServices { get; }
+ 	public string Name { get; }
+ 	public GattDeviceService GetGattService( Guid service );
+ 	public static IAsyncOperation<BluetoothLEDevice> FromIdAsync( string operation );
+ 	public static IAsyncOperation<BluetoothLEDevice> FromBluetoothAddressAsync( ulong operation );
+ 	public static string GetDeviceSelector();
+ 	TypedEventHandler<BluetoothLEDevice, object> ConnectionStatusChanged;
+ 	TypedEventHandler<BluetoothLEDevice, object> GattServicesChanged;
+ 	TypedEventHandler<BluetoothLEDevice, object> NameChanged;
+ }

+ public enum Windows.Devices.Bluetooth.BluetoothMajorClass {
+ 	Miscellaneous = 0,
+ 	Computer = 1,
+ 	Phone = 2,
+ 	NetworkAccessPoint = 3,
+ 	AudioVideo = 4,
+ 	Peripheral = 5,
+ 	Imaging = 6,
+ 	Wearable = 7,
+ 	Toy = 8,
+ 	Health = 9,
+ }

+ public enum Windows.Devices.Bluetooth.BluetoothMinorClass {
+ 	Uncategorized = 0,
+ 	ComputerDesktop = 1,
+ 	ComputerServer = 2,
+ 	ComputerLaptop = 3,
+ 	ComputerHandheld = 4,
+ 	ComputerPalmSize = 5,
+ 	ComputerWearable = 6,
+ 	ComputerTablet = 7,
+ 	PhoneCellular = 1,
+ 	PhoneCordless = 2,
+ 	PhoneSmartPhone = 3,
+ 	PhoneWired = 4,
+ 	PhoneIsdn = 5,
+ 	NetworkFullyAvailable = 0,
+ 	NetworkUsed01To17Percent = 8,
+ 	NetworkUsed17To33Percent = 16,
+ 	NetworkUsed33To50Percent = 24,
+ 	NetworkUsed50To67Percent = 32,
+ 	NetworkUsed67To83Percent = 40,
+ 	NetworkUsed83To99Percent = 48,
+ 	NetworkNoServiceAvailable = 56,
+ 	AudioVideoWearableHeadset = 1,
+ 	AudioVideoHandsFree = 2,
+ 	AudioVideoMicrophone = 4,
+ 	AudioVideoLoudspeaker = 5,
+ 	AudioVideoHeadphones = 6,
+ 	AudioVideoPortableAudio = 7,
+ 	AudioVideoCarAudio = 8,
+ 	AudioVideoSetTopBox = 9,
+ 	AudioVideoHifiAudioDevice = 10,
+ 	AudioVideoVcr = 11,
+ 	AudioVideoVideoCamera = 12,
+ 	AudioVideoCamcorder = 13,
+ 	AudioVideoVideoMonitor = 14,
+ 	AudioVideoVideoDisplayAndLoudspeaker = 15,
+ 	AudioVideoVideoConferencing = 16,
+ 	AudioVideoGamingOrToy = 18,
+ 	PeripheralJoystick = 1,
+ 	PeripheralGamepad = 2,
+ 	PeripheralRemoteControl = 3,
+ 	PeripheralSensing = 4,
+ 	PeripheralDigitizerTablet = 5,
+ 	PeripheralCardReader = 6,
+ 	PeripheralDigitalPen = 7,
+ 	PeripheralHandheldScanner = 8,
+ 	PeripheralHandheldGesture = 9,
+ 	WearableWristwatch = 1,
+ 	WearablePager = 2,
+ 	WearableJacket = 3,
+ 	WearableHelmet = 4,
+ 	WearableGlasses = 5,
+ 	ToyRobot = 1,
+ 	ToyVehicle = 2,
+ 	ToyDoll = 3,
+ 	ToyController = 4,
+ 	ToyGame = 5,
+ 	HealthBloodPressureMonitor = 1,
+ 	HealthThermometer = 2,
+ 	HealthWeighingScale = 3,
+ 	HealthGlucoseMeter = 4,
+ 	HealthPulseOximeter = 5,
+ 	HealthHeartRateMonitor = 6,
+ 	HealthHealthDataDisplay = 7,
+ 	HealthStepCounter = 8,
+ 	HealthBodyCompositionAnalyzer = 9,
+ 	HealthPeakFlowMonitor = 10,
+ 	HealthMedicationMonitor = 11,
+ 	HealthKneeProsthesis = 12,
+ 	HealthAnkleProsthesis = 13,
+ 	HealthGenericHealthManager = 14,
+ 	HealthPersonalMobilityDevice = 15,
+ }

+ public enum Windows.Devices.Bluetooth.BluetoothServiceCapabilities {
+ 	None = 0,
+ 	LimitedDiscoverableMode = 1,
+ 	PositioningService = 8,
+ 	NetworkingService = 16,
+ 	RenderingService = 32,
+ 	CapturingService = 64,
+ 	ObjectTransferService = 128,
+ 	AudioService = 256,
+ 	TelephoneService = 512,
+ 	InformationService = 1024,
+ }

+ public class Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter {
+ 	public IReference<TimeSpan> SamplingInterval { get; set; }
+ 	public IReference<TimeSpan> OutOfRangeTimeout { get; set; }
+ 	public IReference<short> OutOfRangeThresholdInDBm { get; set; }
+ 	public IReference<short> InRangeThresholdInDBm { get; set; }
+ 	public BluetoothSignalStrengthFilter();
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement {
+ 	public string LocalName { get; set; }
+ 	public IReference<BluetoothLEAdvertisementFlags> Flags { get; set; }
+ 	public IVector<BluetoothLEAdvertisementDataSection> DataSections { get; }
+ 	public IVector<BluetoothLEManufacturerData> ManufacturerData { get; }
+ 	public IVector<Guid> ServiceUuids { get; }
+ 	public BluetoothLEAdvertisement();
+ 	public IVectorView<BluetoothLEManufacturerData> GetManufacturerDataByCompanyId( ushort dataList );
+ 	public IVectorView<BluetoothLEAdvertisementDataSection> GetSectionsByType( byte sectionList );
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementBytePattern {
+ 	public short Offset { get; set; }
+ 	public byte DataType { get; set; }
+ 	public IBuffer Data { get; set; }
+ 	public BluetoothLEAdvertisementBytePattern();
+ 	public BluetoothLEAdvertisementBytePattern( byte dataType, short offset, IBuffer data );
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection {
+ 	public byte DataType { get; set; }
+ 	public IBuffer Data { get; set; }
+ 	public BluetoothLEAdvertisementDataSection();
+ 	public BluetoothLEAdvertisementDataSection( byte dataType, IBuffer data );
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataTypes {
+ 	public byte AdvertisingInterval { get; }
+ 	public byte Appearance { get; }
+ 	public byte CompleteLocalName { get; }
+ 	public byte CompleteService128BitUuids { get; }
+ 	public byte CompleteService16BitUuids { get; }
+ 	public byte CompleteService32BitUuids { get; }
+ 	public byte Flags { get; }
+ 	public byte IncompleteService128BitUuids { get; }
+ 	public byte IncompleteService16BitUuids { get; }
+ 	public byte IncompleteService32BitUuids { get; }
+ 	public byte ManufacturerSpecificData { get; }
+ 	public byte PublicTargetAddress { get; }
+ 	public byte RandomTargetAddress { get; }
+ 	public byte ServiceData128BitUuids { get; }
+ 	public byte ServiceData16BitUuids { get; }
+ 	public byte ServiceData32BitUuids { get; }
+ 	public byte ServiceSolicitation128BitUuids { get; }
+ 	public byte ServiceSolicitation16BitUuids { get; }
+ 	public byte ServiceSolicitation32BitUuids { get; }
+ 	public byte ShortenedLocalName { get; }
+ 	public byte SlaveConnectionIntervalRange { get; }
+ 	public byte TxPowerLevel { get; }
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter {
+ 	public BluetoothLEAdvertisement Advertisement { get; set; }
+ 	public IVector<BluetoothLEAdvertisementBytePattern> BytePatterns { get; }
+ 	public BluetoothLEAdvertisementFilter();
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFlags {
+ 	None = 0,
+ 	LimitedDiscoverableMode = 1,
+ 	GeneralDiscoverableMode = 2,
+ 	ClassicNotSupported = 4,
+ 	DualModeControllerCapable = 8,
+ 	DualModeHostCapable = 16,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher {
+ 	public BluetoothLEAdvertisement Advertisement { get; }
+ 	public BluetoothLEAdvertisementPublisherStatus Status { get; }
+ 	public BluetoothLEAdvertisementPublisher();
+ 	public BluetoothLEAdvertisementPublisher( BluetoothLEAdvertisement advertisement );
+ 	public void Start();
+ 	public void Stop();
+ 	TypedEventHandler<BluetoothLEAdvertisementPublisher, BluetoothLEAdvertisementPublisherStatusChangedEventArgs> StatusChanged;
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatus {
+ 	Created = 0,
+ 	Waiting = 1,
+ 	Started = 2,
+ 	Stopping = 3,
+ 	Stopped = 4,
+ 	Aborted = 5,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs {
+ 	public BluetoothError Error { get; }
+ 	public BluetoothLEAdvertisementPublisherStatus Status { get; }
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs {
+ 	public BluetoothLEAdvertisement Advertisement { get; }
+ 	public BluetoothLEAdvertisementType AdvertisementType { get; }
+ 	public ulong BluetoothAddress { get; }
+ 	public string DeviceId { get; }
+ 	public short RawSignalStrengthInDBm { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementType {
+ 	ConnectableUndirected = 0,
+ 	ConnectableDirected = 1,
+ 	ScannableUndirected = 2,
+ 	NonConnectableUndirected = 3,
+ 	ScanResponse = 4,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher {
+ 	public BluetoothSignalStrengthFilter SignalStrengthFilter { get; set; }
+ 	public BluetoothLEScanningMode ScanningMode { get; set; }
+ 	public BluetoothLEAdvertisementFilter AdvertisementFilter { get; set; }
+ 	public BluetoothLEAdvertisementWatcherStatus Status { get; }
+ 	public BluetoothLEAdvertisementWatcher();
+ 	public BluetoothLEAdvertisementWatcher( BluetoothLEAdvertisementFilter advertisementFilter );
+ 	public void Start();
+ 	public void Stop();
+ 	TypedEventHandler<BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementReceivedEventArgs> Received;
+ 	TypedEventHandler<BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementWatcherStoppedEventArgs> Stopped;
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStatus {
+ 	Created = 0,
+ 	Started = 1,
+ 	Stopping = 2,
+ 	Stopped = 3,
+ 	Aborted = 4,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs {
+ 	public BluetoothError Error { get; }
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData {
+ 	public IBuffer Data { get; set; }
+ 	public ushort CompanyId { get; set; }
+ 	public BluetoothLEManufacturerData();
+ 	public BluetoothLEManufacturerData( ushort companyId, IBuffer data );
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEScanningMode {
+ 	Passive = 0,
+ 	Active = 1,
+ }

| public class Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic {
+ 	public GattDeviceService Service { get; }
+ 	public IVectorView<GattDescriptor> GetAllDescriptors();
| }

| public class Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicUuids {
+ 	public Guid AlertCategoryId { get; }
+ 	public Guid AlertCategoryIdBitMask { get; }
+ 	public Guid AlertLevel { get; }
+ 	public Guid AlertNotificationControlPoint { get; }
+ 	public Guid AlertStatus { get; }
+ 	public Guid BootKeyboardInputReport { get; }
+ 	public Guid BootKeyboardOutputReport { get; }
+ 	public Guid BootMouseInputReport { get; }
+ 	public Guid CurrentTime { get; }
+ 	public Guid CyclingPowerControlPoint { get; }
+ 	public Guid CyclingPowerFeature { get; }
+ 	public Guid CyclingPowerMeasurement { get; }
+ 	public Guid CyclingPowerVector { get; }
+ 	public Guid DateTime { get; }
+ 	public Guid DayDateTime { get; }
+ 	public Guid DayOfWeek { get; }
+ 	public Guid DstOffset { get; }
+ 	public Guid ExactTime256 { get; }
+ 	public Guid FirmwareRevisionString { get; }
+ 	public Guid GapAppearance { get; }
+ 	public Guid GapDeviceName { get; }
+ 	public Guid GapPeripheralPreferredConnectionParameters { get; }
+ 	public Guid GapPeripheralPrivacyFlag { get; }
+ 	public Guid GapReconnectionAddress { get; }
+ 	public Guid GattServiceChanged { get; }
+ 	public Guid HardwareRevisionString { get; }
+ 	public Guid HidControlPoint { get; }
+ 	public Guid HidInformation { get; }
+ 	public Guid Ieee1107320601RegulatoryCertificationDataList { get; }
+ 	public Guid LnControlPoint { get; }
+ 	public Guid LnFeature { get; }
+ 	public Guid LocalTimeInformation { get; }
+ 	public Guid LocationAndSpeed { get; }
+ 	public Guid ManufacturerNameString { get; }
+ 	public Guid ModelNumberString { get; }
+ 	public Guid Navigation { get; }
+ 	public Guid NewAlert { get; }
+ 	public Guid PnpId { get; }
+ 	public Guid PositionQuality { get; }
+ 	public Guid ProtocolMode { get; }
+ 	public Guid ReferenceTimeInformation { get; }
+ 	public Guid Report { get; }
+ 	public Guid ReportMap { get; }
+ 	public Guid RingerControlPoint { get; }
+ 	public Guid RingerSetting { get; }
+ 	public Guid ScanIntervalWindow { get; }
+ 	public Guid ScanRefresh { get; }
+ 	public Guid SerialNumberString { get; }
+ 	public Guid SoftwareRevisionString { get; }
+ 	public Guid SupportUnreadAlertCategory { get; }
+ 	public Guid SupportedNewAlertCategory { get; }
+ 	public Guid SystemId { get; }
+ 	public Guid TimeAccuracy { get; }
+ 	public Guid TimeSource { get; }
+ 	public Guid TimeUpdateControlPoint { get; }
+ 	public Guid TimeUpdateState { get; }
+ 	public Guid TimeWithDst { get; }
+ 	public Guid TimeZone { get; }
+ 	public Guid TxPowerLevel { get; }
+ 	public Guid UnreadAlertStatus { get; }
| }

| public class Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService {
+ 	public BluetoothLEDevice Device { get; }
+ 	public IVectorView<GattDeviceService> ParentServices { get; }
+ 	public IVectorView<GattCharacteristic> GetAllCharacteristics();
+ 	public IVectorView<GattDeviceService> GetAllIncludedServices();
| }

| public class Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceUuids {
+ 	public Guid AlertNotification { get; }
+ 	public Guid CurrentTime { get; }
+ 	public Guid CyclingPower { get; }
+ 	public Guid DeviceInformation { get; }
+ 	public Guid HumanInterfaceDevice { get; }
+ 	public Guid ImmediateAlert { get; }
+ 	public Guid LinkLoss { get; }
+ 	public Guid LocationAndNavigation { get; }
+ 	public Guid NextDstChange { get; }
+ 	public Guid PhoneAlertStatus { get; }
+ 	public Guid ReferenceTimeUpdate { get; }
+ 	public Guid ScanParameters { get; }
+ 	public Guid TxPower { get; }
| }

| public class Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService {
+ 	public BluetoothDevice Device { get; }
| }

+ public class Windows.Devices.Casting.AppLaunchCastingSource {
+ 	public CastingSourceType Type { get; }
+ 	public string ApplicationName { get; }
+ 	public string Arguments { get; }
+ 	public AppLaunchCastingSource( string appName, string arguments );
+ }

+ public class Windows.Devices.Casting.CastingDevice {
+ 	public ICastingSource CastingSource { get; }
+ 	public CastingDeviceConnection Connection { get; }
+ 	public CastingDeviceProperties Properties { get; }
+ 	public IAsyncOperation<CastingDeviceConnectionState> CastAsync( ICastingSource operation );
+ 	public static string GetCastingDeviceSelector( CastingTypes value );
+ 	public static string GetCastingSourceDeviceSelector( ICastingSource value );
+ 	public static IAsyncOperation<CastingDevice> FromDeviceInformationAsync( DeviceInformation operation );
+ }

+ public class Windows.Devices.Casting.CastingDeviceConnection {
+ 	public CastingDeviceConnectionState State { get; }
+ 	public IAsyncOperation<CastingDeviceConnectionState> DisconnectAsync();
+ 	public IAsyncOperation<CastingDeviceConnectionState> ReconnectAsync();
+ 	TypedEventHandler<CastingDeviceConnection, CastingDeviceConnectionErrorEventArgs> Error;
+ 	TypedEventHandler<CastingDeviceConnection, CastingDeviceConnectionStateChangedEventArgs> StateChanged;
+ }

+ public enum Windows.Devices.Casting.CastingDeviceConnectionError {
+ 	None = 0,
+ 	DeviceNotResponding = 1,
+ 	DeviceError = 2,
+ 	DeviceLocked = 3,
+ 	ProtectedPlaybackFailed = 4,
+ 	InvalidCastingSource = 5,
+ }

+ public class Windows.Devices.Casting.CastingDeviceConnectionErrorEventArgs {
+ 	public CastingDeviceConnectionError Code { get; }
+ 	public string Message { get; }
+ }

+ public enum Windows.Devices.Casting.CastingDeviceConnectionState {
+ 	Disconnecting = 0,
+ 	Disconnected = 1,
+ 	Connecting = 2,
+ 	Connected = 3,
+ 	Rendering = 4,
+ }

+ public class Windows.Devices.Casting.CastingDeviceConnectionStateChangedEventArgs {
+ 	public CastingDeviceConnectionState CurrentState { get; }
+ 	public CastingDeviceConnectionState PreviousState { get; }
+ }

+ public class Windows.Devices.Casting.CastingDeviceProperties {
+ 	public DeviceInformation DeviceInformation { get; }
+ 	public string FriendlyName { get; }
+ 	public IRandomAccessStreamWithContentType Icon { get; }
+ 	public CastingTypes SupportedCastingTypes { get; }
+ 	public IAsyncOperation<IMap<string, object>> GetPropertiesAsync( IIterable<string> operation );
+ }

+ public class Windows.Devices.Casting.CastingDeviceSelectedEventArgs {
+ 	public ICastingDevice SelectedDevice { get; }
+ }

+ public class Windows.Devices.Casting.CastingDeviceSelectorRequest {
+ 	public string DeviceSelector { get; set; }
+ 	public CastingDeviceSelectorRequestDeferral GetDeferral();
+ }

+ public class Windows.Devices.Casting.CastingDeviceSelectorRequestDeferral {
+ 	public void Complete();
+ }

+ public class Windows.Devices.Casting.CastingDeviceSelectorRequestedEventArgs {
+ 	public CastingDeviceSelectorRequest Request { get; }
+ }

+ public enum Windows.Devices.Casting.CastingSourceType {
+ 	Unknown = 0,
+ 	MediaElement = 1,
+ 	Image = 2,
+ 	Stream = 3,
+ 	Uri = 4,
+ 	Window = 5,
+ 	App = 6,
+ }

+ public enum Windows.Devices.Casting.CastingTypes {
+ 	None = 0,
+ 	Audio = 1,
+ 	Video = 2,
+ 	Image = 4,
+ 	AppLaunch = 8,
+ 	Window = 16,
+ }

+ public class Windows.Devices.Casting.CastingUI {
+ 	public CastingUI Current { get; }
+ 	public static void ShowUI();
+ 	TypedEventHandler<CastingUI, CastingDeviceSelectedEventArgs> DeviceSelected;
+ 	TypedEventHandler<CastingUI, CastingDeviceSelectorRequestedEventArgs> DeviceSelectorRequested;
+ }

+ public interface Windows.Devices.Casting.ICastingDevice {
+ 	public ICastingSource CastingSource { get; }
+ 	public CastingDeviceConnection Connection { get; }
+ 	public CastingDeviceProperties Properties { get; }
+ 	public IAsyncOperation<CastingDeviceConnectionState> CastAsync( ICastingSource operation );
+ }

+ public interface Windows.Devices.Casting.ICastingDeviceStatics {
+ 	public string GetCastingDeviceSelector( CastingTypes value );
+ 	public string GetCastingSourceDeviceSelector( ICastingSource value );
+ 	public IAsyncOperation<CastingDevice> FromDeviceInformationAsync( DeviceInformation operation );
+ }

+ public interface Windows.Devices.Casting.ICastingSource {
+ 	public CastingSourceType Type { get; }
+ }

+ public interface Windows.Devices.Casting.ICastingUIStatics {
+ 	public CastingUI Current { get; }
+ 	public void ShowUI();
+ }

+ public interface Windows.Devices.Casting.IMediaCastingSource {
+ 	public Uri PreferredSourceUri { get; set; }
+ }

+ public class Windows.Devices.Casting.ImageCastingSource {
+ 	public Image Image { get; }
+ 	public Uri PreferredSourceUri { get; set; }
+ 	public CastingSourceType Type { get; }
+ 	public ImageCastingSource( Image element );
+ }

+ public class Windows.Devices.Casting.MediaElementCastingSource {
+ 	public MediaElement MediaElement { get; }
+ 	public Uri PreferredSourceUri { get; set; }
+ 	public CastingSourceType Type { get; }
+ 	public MediaElementCastingSource( MediaElement element );
+ }

+ public class Windows.Devices.Casting.MshtmlCastingSource {
+ 	public CastingSourceType Type { get; }
+ 	public Uri PreferredSourceUri { get; set; }
+ }

+ public class Windows.Devices.Casting.StreamCastingSource {
+ 	public IRandomAccessStream Stream { get; }
+ 	public Uri PreferredSourceUri { get; set; }
+ 	public CastingSourceType Type { get; }
+ 	public StreamCastingSource( IRandomAccessStream stream );
+ }

+ public class Windows.Devices.Casting.UriCastingSource {
+ 	public Uri PreferredSourceUri { get; set; }
+ 	public Uri Uri { get; }
+ 	public CastingSourceType Type { get; }
+ 	public UriCastingSource( Uri uri );
+ }

+ public class Windows.Devices.Casting.WindowCastingSource {
+ 	public ICoreWindow Window { get; }
+ 	public CastingSourceType Type { get; }
+ 	public WindowCastingSource( ICoreWindow window );
+ }

| public enum Windows.Devices.Enumeration.Pnp.PnpObjectType {
+ 	AssociationEndpoint = 5,
+ 	AssociationEndpointContainer = 6,
+ 	AssociationEndpointService = 7,
| }

+ public class Windows.Devices.Geolocation.GeoboundingBox {
+ 	public BasicGeoposition Center { get; }
+ 	public double MaxAltitude { get; }
+ 	public double MinAltitude { get; }
+ 	public BasicGeoposition NorthwestCorner { get; }
+ 	public BasicGeoposition SoutheastCorner { get; }
+ 	public AltitudeReferenceSystem AltitudeReferenceSystem { get; }
+ 	public GeoshapeType GeoshapeType { get; }
+ 	public uint SpatialReferenceId { get; }
+ 	public GeoboundingBox( BasicGeoposition northwestCorner, BasicGeoposition southeastCorner );
+ 	public GeoboundingBox( BasicGeoposition northwestCorner, BasicGeoposition southeastCorner, AltitudeReferenceSystem altitudeReferenceSystem );
+ 	public GeoboundingBox( BasicGeoposition northwestCorner, BasicGeoposition southeastCorner, AltitudeReferenceSystem altitudeReferenceSystem, uint spatialReferenceId );
+ 	public static GeoboundingBox TryCompute( IIterable<BasicGeoposition> value );
+ 	public static GeoboundingBox TryCompute( IIterable<BasicGeoposition> value, AltitudeReferenceSystem positions );
+ 	public static GeoboundingBox TryCompute( IIterable<BasicGeoposition> value, AltitudeReferenceSystem positions, uint altitudeRefSystem );
+ }

| public class Windows.Devices.Geolocation.Geocoordinate {
+ 	public GeocoordinateVenueData VenueData { get; }
| }

+ public class Windows.Devices.Geolocation.GeocoordinateVenueData {
+ 	public string Id { get; }
+ 	public string Level { get; }
+ }

+ public class Windows.Devices.Geolocation.Geopath {
+ 	public AltitudeReferenceSystem AltitudeReferenceSystem { get; }
+ 	public GeoshapeType GeoshapeType { get; }
+ 	public uint SpatialReferenceId { get; }
+ 	public IVectorView<BasicGeoposition> Positions { get; }
+ 	public Geopath( IIterable<BasicGeoposition> positions );
+ 	public Geopath( IIterable<BasicGeoposition> positions, AltitudeReferenceSystem altitudeReferenceSystem );
+ 	public Geopath( IIterable<BasicGeoposition> positions, AltitudeReferenceSystem altitudeReferenceSystem, uint spatialReferenceId );
+ }

| public enum Windows.Devices.Geolocation.GeoshapeType {
+ 	Geopath = 2,
+ 	GeoboundingBox = 3,
| }

+ public class Windows.Devices.Lights.Lamp {
+ 	public bool IsEnabled { get; set; }
+ 	public Color Color { get; set; }
+ 	public float BrightnessLevel { get; set; }
+ 	public string DeviceId { get; }
+ 	public bool IsColorSettable { get; }
+ 	public void Close();
+ 	public static string GetDeviceSelector();
+ 	public static IAsyncOperation<Lamp> FromIdAsync( string operation );
+ 	public static IAsyncOperation<Lamp> GetDefaultAsync();
+ 	TypedEventHandler<Lamp, LampAvailabilityChangedEventArgs> AvailabilityChanged;
+ }

+ public class Windows.Devices.Lights.LampAvailabilityChangedEventArgs {
+ 	public bool IsAvailable { get; }
+ }

+ public interface Windows.Devices.Midi.IMidiMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ }

+ public interface Windows.Devices.Midi.IMidiOutPort {
+ 	public string DeviceId { get; }
+ 	public void SendMessage( IMidiMessage midiMessage );
+ 	public void SendBuffer( IBuffer midiData );
+ }

+ public class Windows.Devices.Midi.MidiActiveSensingMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiActiveSensingMessage();
+ }

+ public class Windows.Devices.Midi.MidiChannelPressureMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public byte Channel { get; }
+ 	public byte Pressure { get; }
+ 	public MidiChannelPressureMessage( byte channel, byte pressure );
+ }

+ public class Windows.Devices.Midi.MidiContinueMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiContinueMessage();
+ }

+ public class Windows.Devices.Midi.MidiControlChangeMessage {
+ 	public byte Channel { get; }
+ 	public byte ControlValue { get; }
+ 	public byte Controller { get; }
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiControlChangeMessage( byte channel, byte controller, byte controlValue );
+ }

+ public class Windows.Devices.Midi.MidiInPort {
+ 	public string DeviceId { get; }
+ 	public void Close();
+ 	public static IAsyncOperation<MidiInPort> FromIdAsync( string value );
+ 	public static string GetDeviceSelector();
+ 	TypedEventHandler<MidiInPort, MidiMessageReceivedEventArgs> MessageReceived;
+ }

+ public class Windows.Devices.Midi.MidiMessageReceivedEventArgs {
+ 	public IMidiMessage Message { get; }
+ }

+ public enum Windows.Devices.Midi.MidiMessageType {
+ 	None = 0,
+ 	NoteOff = 128,
+ 	NoteOn = 144,
+ 	PolyphonicKeyPressure = 160,
+ 	ControlChange = 176,
+ 	ProgramChange = 192,
+ 	ChannelPressure = 208,
+ 	PitchBendChange = 224,
+ 	SystemExclusive = 240,
+ 	MidiTimeCode = 241,
+ 	SongPositionPointer = 242,
+ 	SongSelect = 243,
+ 	TuneRequest = 246,
+ 	TimingClock = 248,
+ 	Start = 250,
+ 	Continue = 251,
+ 	Stop = 252,
+ 	ActiveSensing = 254,
+ 	SystemReset = 255,
+ }

+ public class Windows.Devices.Midi.MidiNoteOffMessage {
+ 	public byte Channel { get; }
+ 	public byte Note { get; }
+ 	public byte Velocity { get; }
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiNoteOffMessage( byte channel, byte note, byte velocity );
+ }

+ public class Windows.Devices.Midi.MidiNoteOnMessage {
+ 	public byte Channel { get; }
+ 	public byte Note { get; }
+ 	public byte Velocity { get; }
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiNoteOnMessage( byte channel, byte note, byte velocity );
+ }

+ public class Windows.Devices.Midi.MidiOutPort {
+ 	public string DeviceId { get; }
+ 	public void SendMessage( IMidiMessage midiMessage );
+ 	public void SendBuffer( IBuffer midiData );
+ 	public void Close();
+ 	public static IAsyncOperation<IMidiOutPort> FromIdAsync( string value );
+ 	public static string GetDeviceSelector();
+ }

+ public class Windows.Devices.Midi.MidiPitchBendChangeMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public ushort Bend { get; }
+ 	public byte Channel { get; }
+ 	public MidiPitchBendChangeMessage( byte channel, ushort bend );
+ }

+ public class Windows.Devices.Midi.MidiPolyphonicKeyPressureMessage {
+ 	public byte Channel { get; }
+ 	public byte Note { get; }
+ 	public byte Pressure { get; }
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiPolyphonicKeyPressureMessage( byte channel, byte note, byte pressure );
+ }

+ public class Windows.Devices.Midi.MidiProgramChangeMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public byte Channel { get; }
+ 	public byte Program { get; }
+ 	public MidiProgramChangeMessage( byte channel, byte program );
+ }

+ public class Windows.Devices.Midi.MidiSongPositionPointerMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public ushort Beats { get; }
+ 	public MidiSongPositionPointerMessage( ushort beats );
+ }

+ public class Windows.Devices.Midi.MidiSongSelectMessage {
+ 	public byte Song { get; }
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiSongSelectMessage( byte song );
+ }

+ public class Windows.Devices.Midi.MidiStartMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiStartMessage();
+ }

+ public class Windows.Devices.Midi.MidiStopMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiStopMessage();
+ }

+ public class Windows.Devices.Midi.MidiSynthesizer {
+ 	public string DeviceId { get; }
+ 	public double Volume { get; set; }
+ 	public DeviceInformation AudioDevice { get; }
+ 	public void SendMessage( IMidiMessage midiMessage );
+ 	public void SendBuffer( IBuffer midiData );
+ 	public void Close();
+ 	public static IAsyncOperation<MidiSynthesizer> CreateAsync();
+ 	public static IAsyncOperation<MidiSynthesizer> CreateAsync( DeviceInformation value );
+ 	public static bool IsSynthesizer( DeviceInformation value );
+ }

+ public class Windows.Devices.Midi.MidiSystemExclusiveMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiSystemExclusiveMessage( IBuffer rawData );
+ }

+ public class Windows.Devices.Midi.MidiSystemResetMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiSystemResetMessage();
+ }

+ public class Windows.Devices.Midi.MidiTimeCodeMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public byte FrameType { get; }
+ 	public byte Values { get; }
+ 	public MidiTimeCodeMessage( byte frameType, byte values );
+ }

+ public class Windows.Devices.Midi.MidiTimingClockMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiTimingClockMessage();
+ }

+ public class Windows.Devices.Midi.MidiTuneRequestMessage {
+ 	public IBuffer RawData { get; }
+ 	public TimeSpan Timestamp { get; }
+ 	public MidiMessageType Type { get; }
+ 	public MidiTuneRequestMessage();
+ }

+ public class Windows.Devices.Power.Battery {
+ 	public string DeviceId { get; }
+ 	public Battery AggregateBattery { get; }
+ 	public BatteryReport GetReport();
+ 	public static IAsyncOperation<Battery> FromIdAsync( string result );
+ 	public static string GetDeviceSelector();
+ 	TypedEventHandler<Battery, object> ReportUpdated;
+ }

+ public class Windows.Devices.Power.BatteryReport {
+ 	public IReference<int> ChargeRateInMilliwatts { get; }
+ 	public IReference<int> DesignCapacityInMilliwattHours { get; }
+ 	public IReference<int> FullChargeCapacityInMilliwattHours { get; }
+ 	public IReference<int> RemainingCapacityInMilliwattHours { get; }
+ 	public BatteryStatus Status { get; }
+ }

| public class Windows.Devices.Sensors.Accelerometer {
+ 	public string DeviceId { get; }
+ 	public DisplayOrientations ReadingTransform { get; set; }
| }

+ public class Windows.Devices.Sensors.ActivitySensor {
+ 	public string DeviceId { get; }
+ 	public uint MinimumReportInterval { get; }
+ 	public float PowerInMilliwatts { get; }
+ 	public ActivitySensorStatus Status { get; }
+ 	public IVector<ActivityType> SubscribedActivities { get; }
+ 	public IVectorView<ActivityType> SupportedActivities { get; }
+ 	public IAsyncOperation<ActivitySensorReading> GetCurrentReadingAsync();
+ 	public static IAsyncOperation<ActivitySensor> GetDefaultAsync();
+ 	public static string GetDeviceSelector();
+ 	public static IAsyncOperation<ActivitySensor> FromIdAsync( string result );
+ 	public static IAsyncOperation<IVectorView<ActivitySensorReading>> GetSystemHistoryAsync( DateTime result );
+ 	public static IAsyncOperation<IVectorView<ActivitySensorReading>> GetSystemHistoryAsync( DateTime result, TimeSpan fromTime );
+ 	TypedEventHandler<ActivitySensor, ActivitySensorReadingChangedEventArgs> ReadingChanged;
+ 	TypedEventHandler<ActivitySensor, ActivitySensorStatusChangedEventArgs> StatusChanged;
+ }

+ public class Windows.Devices.Sensors.ActivitySensorReading {
+ 	public ActivityType Activity { get; }
+ 	public ActivitySensorReadingConfidence Confidence { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.ActivitySensorReadingChangeReport {
+ 	public ActivitySensorReading Reading { get; }
+ }

+ public class Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs {
+ 	public ActivitySensorReading Reading { get; }
+ }

+ public enum Windows.Devices.Sensors.ActivitySensorReadingConfidence {
+ 	High = 0,
+ 	Low = 1,
+ }

+ public enum Windows.Devices.Sensors.ActivitySensorStatus {
+ 	Disabled = 0,
+ 	Enabled = 1,
+ 	Error = 2,
+ }

+ public class Windows.Devices.Sensors.ActivitySensorStatusChangedEventArgs {
+ 	public ActivitySensorStatus Status { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.ActivitySensorTriggerDetails {
+ 	public IVectorView<ActivitySensorReadingChangeReport> ReadReports();
+ }

+ public enum Windows.Devices.Sensors.ActivityType {
+ 	Unknown = 0,
+ 	Stationary = 1,
+ 	Fidgeting = 2,
+ 	Walking = 3,
+ 	Running = 4,
+ 	InVehicle = 5,
+ 	Biking = 6,
+ }

| public class Windows.Devices.Sensors.Compass {
+ 	public string DeviceId { get; }
+ 	public DisplayOrientations ReadingTransform { get; set; }
| }

| public class Windows.Devices.Sensors.Gyrometer {
+ 	public DisplayOrientations ReadingTransform { get; set; }
+ 	public string DeviceId { get; }
| }

| public class Windows.Devices.Sensors.Inclinometer {
+ 	public string DeviceId { get; }
+ 	public DisplayOrientations ReadingTransform { get; set; }
+ 	public SensorReadingType ReadingType { get; }
+ 	public static Inclinometer GetDefaultForRelativeReadings();
| }

| public class Windows.Devices.Sensors.LightSensor {
+ 	public string DeviceId { get; }
| }

+ public class Windows.Devices.Sensors.Magnetometer {
+ 	public uint ReportInterval { get; set; }
+ 	public uint MinimumReportInterval { get; }
+ 	public string DeviceId { get; }
+ 	public DisplayOrientations ReadingTransform { get; set; }
+ 	public MagnetometerReading GetCurrentReading();
+ 	public static Magnetometer GetDefault();
+ 	TypedEventHandler<Magnetometer, MagnetometerReadingChangedEventArgs> ReadingChanged;
+ }

+ public class Windows.Devices.Sensors.MagnetometerReading {
+ 	public MagnetometerAccuracy DirectionalAccuracy { get; }
+ 	public float MagneticFieldX { get; }
+ 	public float MagneticFieldY { get; }
+ 	public float MagneticFieldZ { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs {
+ 	public MagnetometerReading Reading { get; }
+ }

| public class Windows.Devices.Sensors.OrientationSensor {
+ 	public string DeviceId { get; }
+ 	public DisplayOrientations ReadingTransform { get; set; }
+ 	public SensorReadingType ReadingType { get; }
+ 	public static OrientationSensor GetDefaultForRelativeReadings();
| }

+ public enum Windows.Devices.Sensors.SensorReadingType {
+ 	Absolute = 0,
+ 	Relative = 1,
+ }

| public class Windows.Devices.Sensors.SimpleOrientationSensor {
+ 	public string DeviceId { get; }
+ 	public DisplayOrientations ReadingTransform { get; set; }
| }

+ public class Windows.Devices.Sensors.Custom.CustomSensor {
+ 	public uint ReportInterval { get; set; }
+ 	public string DeviceId { get; }
+ 	public uint MinimumReportInterval { get; }
+ 	public CustomSensorReading GetCurrentReading();
+ 	public static string GetDeviceSelector( Guid result );
+ 	public static IAsyncOperation<CustomSensor> FromIdAsync( string result );
+ 	TypedEventHandler<CustomSensor, CustomSensorReadingChangedEventArgs> ReadingChanged;
+ }

+ public class Windows.Devices.Sensors.Custom.CustomSensorReading {
+ 	public IMapView<string, object> Properties { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs {
+ 	public CustomSensorReading Reading { get; }
+ }

| public class Windows.Devices.SmartCards.SmartCard {
+ 	public IAsyncOperation<SmartCardConnection> ConnectAsync();
| }

+ public class Windows.Devices.SmartCards.SmartCardConnection {
+ 	public IAsyncOperation<IBuffer> TransmitAsync( IBuffer result );
+ 	public void Close();
+ }

+ public interface Windows.Devices.Sms.ISmsDevice2 {
+ 	public string DeviceId { get; }
+ 	public string ParentMobileBroadbandModemDeviceId { get; }
+ 	public string SmscAddress { get; set; }
+ 	public IAsyncOperation<SmsSendMessageResult> SendMessageAndGetResultAsync( ISmsMessage2 asyncInfo );
+ }

+ public interface Windows.Devices.Sms.ISmsMessage2 {
+ 	public CellularClass CellularClass { get; }
+ 	public string DeviceId { get; }
+ 	public SmsMessageType MessageType { get; }
+ }

+ public class Windows.Devices.Sms.SmsAppMessage {
+ 	public string To { get; set; }
+ 	public int RetryAttemptCount { get; set; }
+ 	public int PortNumber { get; set; }
+ 	public bool IsDeliveryNotificationEnabled { get; set; }
+ 	public SmsEncoding Encoding { get; set; }
+ 	public string CallbackNumber { get; set; }
+ 	public string Body { get; set; }
+ 	public IBuffer BinaryBody { get; set; }
+ 	public string From { get; }
+ 	public DateTime Timestamp { get; }
+ 	public CellularClass CellularClass { get; }
+ 	public string DeviceId { get; }
+ 	public SmsMessageType MessageType { get; }
+ 	public uint Id { get; }
+ 	public SmsMessageClass MessageClass { get; }
+ 	public SmsAppMessage();
+ }

+ public class Windows.Devices.Sms.SmsBroadcastMessage {
+ 	public uint Id { get; }
+ 	public SmsMessageClass MessageClass { get; }
+ 	public CellularClass CellularClass { get; }
+ 	public string DeviceId { get; }
+ 	public SmsMessageType MessageType { get; }
+ 	public string Body { get; }
+ 	public SmsBroadcastType BroadcastType { get; }
+ 	public int Channel { get; }
+ 	public SmsGeographicalScope GeographicalScope { get; }
+ 	public bool IsEmergencyAlert { get; }
+ 	public bool IsUserPopupEnabled { get; }
+ 	public int MessageCode { get; }
+ 	public DateTime Timestamp { get; }
+ 	public string To { get; }
+ 	public int UpdateNumber { get; }
+ }

+ public enum Windows.Devices.Sms.SmsBroadcastType {
+ 	Other = 0,
+ 	CmasPresidential = 1,
+ 	CmasExtreme = 2,
+ 	CmasSevere = 3,
+ 	CmasAmber = 4,
+ 	CmasTest = 5,
+ 	EUAlert1 = 6,
+ 	EUAlert2 = 7,
+ 	EUAlert3 = 8,
+ 	EUAlertAmber = 9,
+ 	EUAlertInfo = 10,
+ 	EtwsEarthquake = 11,
+ 	EtwsTsunami = 12,
+ 	EtwsTsunamiAndEarthquake = 13,
+ 	LatAlertLocal = 14,
+ }

| public class Windows.Devices.Sms.SmsDevice {
+ 	public string SmscAddress { get; set; }
+ 	public string DeviceId { get; }
+ 	public string ParentMobileBroadbandModemDeviceId { get; }
+ 	public IAsyncOperation<SmsSendMessageResult> SendMessageAndGetResultAsync( ISmsMessage2 asyncInfo );
| }

| public enum Windows.Devices.Sms.SmsEncoding {
+ 	GsmEightBit = 5,
+ 	Octet = 6,
+ 	Latin = 7,
+ 	Korean = 8,
+ 	IA5 = 9,
+ 	ShiftJis = 10,
+ 	LatinHebrew = 11,
| }

+ public enum Windows.Devices.Sms.SmsFilterActionType {
+ 	AcceptImmediately = 0,
+ 	Drop = 1,
+ 	Peek = 2,
+ 	Accept = 3,
+ }

+ public class Windows.Devices.Sms.SmsFilterRule {
+ 	public string WapContentType { get; set; }
+ 	public string WapApplicationId { get; set; }
+ 	public string TextMessagePrefix { get; set; }
+ 	public IVector<int> TeleserviceId { get; set; }
+ 	public IVector<string> SenderNumbers { get; set; }
+ 	public IVector<int> ProtocolId { get; set; }
+ 	public IVector<int> PortNumbers { get; set; }
+ 	public SmsMessageType MessageType { get; set; }
+ 	public string ImsiPrefix { get; set; }
+ 	public string DeviceId { get; set; }
+ 	public CellularClass CellularClass { get; set; }
+ 	public SmsBroadcastType BroadcastType { get; set; }
+ 	public int BroadcastChannel { get; set; }
+ 	public SmsFilterRule();
+ }

+ public class Windows.Devices.Sms.SmsFilterRules {
+ 	public IVector<SmsFilterRule> Rules { get; set; }
+ 	public SmsFilterActionType ActionType { get; set; }
+ 	public SmsFilterRules();
+ }

+ public enum Windows.Devices.Sms.SmsGeographicalScope {
+ 	None = 0,
+ 	CellWithImmediateDisplay = 1,
+ 	LocationArea = 2,
+ 	Plmn = 3,
+ 	Cell = 4,
+ }

+ public class Windows.Devices.Sms.SmsMessageReceivedTriggerDetails {
+ 	public SmsAppMessage AppMessage { get; }
+ 	public SmsBroadcastMessage BroadcastMessage { get; }
+ 	public SmsMessageType MessageType { get; }
+ 	public SmsStatusMessage StatusMessage { get; }
+ 	public SmsTextMessage TextMessage { get; }
+ 	public SmsVoicemailMessage VoicemailMessage { get; }
+ 	public SmsWapMessage WapMessage { get; }
+ 	public void Drop();
+ 	public void Accept();
+ }

+ public enum Windows.Devices.Sms.SmsMessageStatus {
+ 	Unknown = 0,
+ 	ReceivedByShortMessageEntity = 1,
+ 	ForwardedToShortMessageEntity = 2,
+ 	ReplacedBySmsc = 3,
+ 	CongestionTrying = 4,
+ 	ShortMessageEntityBusyTrying = 5,
+ 	ShortMessageEntityNotRespondingTrying = 6,
+ 	ServiceRejectedTrying = 7,
+ 	QualityOfServiceUnavailableTrying = 8,
+ 	ShortMessageEntityErrorTrying = 9,
+ 	Congestion = 10,
+ 	ShortMessageEntityBusy = 11,
+ 	ShortMessageEntityNotResponding = 12,
+ 	ServiceRejected = 13,
+ 	QualityOfServiceTemporilyUnavailable = 14,
+ 	ShortMessageEntityError = 15,
+ 	RemoteProcedureError = 16,
+ 	IncompatibleDestination = 17,
+ 	ConnectionRejected = 18,
+ 	NotObtainable = 19,
+ 	NoInterworkingAvailable = 20,
+ 	ValidityPeriodExpired = 21,
+ 	DeletedByOriginatingShortMessageEntity = 22,
+ 	DeletedBySmsc = 23,
+ 	MessageDoesNotExist = 24,
+ 	QualityUnavailable = 25,
+ 	ReservedCompleted = 26,
+ 	ReservedTrying = 27,
+ 	ReservedError = 28,
+ 	ReservedTemporaryError = 29,
+ 	SmscSpecificCompleted = 30,
+ 	SmscSpecificTrying = 31,
+ 	SmscSpecificError = 32,
+ 	SmscSpecificTemporaryError = 33,
+ }

| public enum Windows.Devices.Sms.SmsMessageType {
+ 	Wap = 2,
+ 	App = 3,
+ 	Broadcast = 4,
+ 	Voicemail = 5,
+ 	Status = 6,
| }

+ public class Windows.Devices.Sms.SmsSendMessageResult {
+ 	public CellularClass CellularClass { get; }
+ 	public HResult ErrorCode { get; }
+ 	public bool IsErrorTransient { get; }
+ 	public IVectorView<int> MessageReferenceNumbers { get; }
+ 	public int NetworkCauseCode { get; }
+ 	public int TransportFailureCause { get; }
+ }

+ public class Windows.Devices.Sms.SmsStatusMessage {
+ 	public uint Id { get; }
+ 	public SmsMessageClass MessageClass { get; }
+ 	public CellularClass CellularClass { get; }
+ 	public string DeviceId { get; }
+ 	public SmsMessageType MessageType { get; }
+ 	public DateTime DischargeTime { get; }
+ 	public string From { get; }
+ 	public int MessageReferenceNumber { get; }
+ 	public DateTime ServiceCenterTimestamp { get; }
+ 	public SmsMessageStatus Status { get; }
+ 	public string To { get; }
+ }

| public class Windows.Devices.Sms.SmsTextMessage {
+ 	public int TeleserviceId { get; set; }
+ 	public int RetryAttemptCount { get; set; }
+ 	public bool IsDeliveryNotificationEnabled { get; set; }
+ 	public string CallbackNumber { get; set; }
+ 	public int ProtocolId { get; }
+ 	public CellularClass CellularClass { get; }
+ 	public string DeviceId { get; }
+ 	public SmsMessageType MessageType { get; }
| }

+ public class Windows.Devices.Sms.SmsVoicemailMessage {
+ 	public CellularClass CellularClass { get; }
+ 	public string DeviceId { get; }
+ 	public SmsMessageType MessageType { get; }
+ 	public string Body { get; }
+ 	public IReference<int> MessageCount { get; }
+ 	public DateTime Timestamp { get; }
+ 	public string To { get; }
+ 	public uint Id { get; }
+ 	public SmsMessageClass MessageClass { get; }
+ }

+ public class Windows.Devices.Sms.SmsWapMessage {
+ 	public string ApplicationId { get; }
+ 	public IBuffer BinaryBody { get; }
+ 	public string ContentType { get; }
+ 	public string From { get; }
+ 	public IMap<string, string> Headers { get; }
+ 	public DateTime Timestamp { get; }
+ 	public string To { get; }
+ 	public CellularClass CellularClass { get; }
+ 	public string DeviceId { get; }
+ 	public SmsMessageType MessageType { get; }
+ 	public uint Id { get; }
+ 	public SmsMessageClass MessageClass { get; }
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectAdvertisement {
+ 	public WiFiDirectAdvertisementListenStateDiscoverability ListenStateDiscoverability { get; set; }
+ 	public bool IsAutonomousGroupOwnerEnabled { get; set; }
+ 	public IVector<WiFiDirectInformationElement> InformationElements { get; set; }
+ }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectAdvertisementListenStateDiscoverability {
+ 	None = 0,
+ 	Normal = 1,
+ 	Intensive = 2,
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher {
+ 	public WiFiDirectAdvertisement Advertisement { get; }
+ 	public WiFiDirectAdvertisementPublisherStatus Status { get; }
+ 	public WiFiDirectAdvertisementPublisher();
+ 	public void Start();
+ 	public void Stop();
+ 	TypedEventHandler<WiFiDirectAdvertisementPublisher, WiFiDirectAdvertisementPublisherStatusChangedEventArgs> StatusChanged;
+ }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatus {
+ 	Created = 0,
+ 	Started = 1,
+ 	Stopped = 2,
+ 	Aborted = 3,
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs {
+ 	public WiFiDirectError Error { get; }
+ 	public WiFiDirectAdvertisementPublisherStatus Status { get; }
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionListener {
+ 	public WiFiDirectConnectionListener();
+ 	TypedEventHandler<WiFiDirectConnectionListener, WiFiDirectConnectionRequestedEventArgs> ConnectionRequested;
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionParameters {
+ 	public short GroupOwnerIntent { get; set; }
+ 	public WiFiDirectConnectionParameters();
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionRequest {
+ 	public DeviceInformation DeviceInformation { get; }
+ 	public void Close();
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs {
+ 	public WiFiDirectConnectionRequest GetConnectionRequest();
+ }

| public class Windows.Devices.WiFiDirect.WiFiDirectDevice {
+ 	public static string GetDeviceSelector( WiFiDirectDeviceSelectorType result );
+ 	public static IAsyncOperation<WiFiDirectDevice> FromIdAsync( string result, WiFiDirectConnectionParameters deviceId );
| }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectDeviceSelectorType {
+ 	DeviceInterface = 0,
+ 	AssociationEndpoint = 1,
+ }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectError {
+ 	Success = 0,
+ 	RadioNotAvailable = 1,
+ 	ResourceInUse = 2,
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectInformationElement {
+ 	public IBuffer Value { get; set; }
+ 	public byte OuiType { get; set; }
+ 	public IBuffer Oui { get; set; }
+ 	public WiFiDirectInformationElement();
+ 	public static IVector<WiFiDirectInformationElement> CreateFromBuffer( IBuffer result );
+ 	public static IVector<WiFiDirectInformationElement> CreateFromDeviceInformation( DeviceInformation result );
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectService {
+ 	public bool PreferGroupOwnerMode { get; set; }
+ 	public IBuffer RemoteServiceInfo { get; }
+ 	public IVectorView<WiFiDirectServiceConfigurationMethod> SupportedConfigurationMethods { get; }
+ 	public IAsyncOperation<WiFiDirectServiceProvisioningInfo> GetProvisioningInfoAsync( WiFiDirectServiceConfigurationMethod result );
+ 	public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync();
+ 	public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync( string result );
+ 	public static string GetSelector( string serviceSelector );
+ 	public static string GetSelector( string serviceSelector, IBuffer serviceName );
+ 	public static WiFiDirectService FromId( string wifiDirectService );
+ 	TypedEventHandler<WiFiDirectService, WiFiDirectServiceSessionDeferredEventArgs> SessionDeferred;
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertisementStatus {
+ 	Created = 0,
+ 	Started = 1,
+ 	Stopped = 2,
+ 	Aborted = 3,
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser {
+ 	public WiFiDirectServiceStatus ServiceStatus { get; set; }
+ 	public IBuffer ServiceInfo { get; set; }
+ 	public bool PreferGroupOwnerMode { get; set; }
+ 	public IBuffer DeferredSessionInfo { get; set; }
+ 	public uint CustomServiceStatusCode { get; set; }
+ 	public bool AutoAcceptSession { get; set; }
+ 	public WiFiDirectServiceAdvertisementStatus AdvertisementStatus { get; }
+ 	public IVector<WiFiDirectServiceConfigurationMethod> PreferredConfigurationMethods { get; }
+ 	public WiFiDirectServiceError ServiceError { get; }
+ 	public string ServiceName { get; }
+ 	public WiFiDirectServiceAdvertiser( string serviceName );
+ 	public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync( DeviceInformation result );
+ 	public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync( DeviceInformation result, string deviceInfo );
+ 	public void Start();
+ 	public void Stop();
+ 	TypedEventHandler<WiFiDirectServiceAdvertiser, object> AdvertisementStatusChanged;
+ 	TypedEventHandler<WiFiDirectServiceAdvertiser, WiFiDirectServiceAutoAcceptSessionConnectedEventArgs> AutoAcceptSessionConnected;
+ 	TypedEventHandler<WiFiDirectServiceAdvertiser, WiFiDirectServiceSessionRequestedEventArgs> SessionRequested;
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs {
+ 	public WiFiDirectServiceSession Session { get; }
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceConfigurationMethod {
+ 	Default = 0,
+ 	PinDisplay = 1,
+ 	PinEntry = 2,
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceError {
+ 	Success = 0,
+ 	RadioNotAvailable = 1,
+ 	ResourceInUse = 2,
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceProvisioningInfo {
+ 	public bool IsGroupFormationNeeded { get; }
+ 	public WiFiDirectServiceConfigurationMethod SelectedConfigurationMethod { get; }
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs {
+ 	public IVectorView<EndpointPair> EndpointPairs { get; }
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession {
+ 	public WiFiDirectServiceSessionErrorStatus ErrorStatus { get; }
+ 	public string ServiceName { get; }
+ 	public WiFiDirectServiceSessionStatus Status { get; }
+ 	public IVectorView<EndpointPair> GetConnectionEndpointPairs();
+ 	public IAsyncAction AddStreamSocketListenerAsync( StreamSocketListener result );
+ 	public IAsyncAction AddDatagramSocketAsync( DatagramSocket result );
+ 	public void Close();
+ 	TypedEventHandler<WiFiDirectServiceSession, WiFiDirectServiceRemotePortAddedEventArgs> RemotePortAdded;
+ 	TypedEventHandler<WiFiDirectServiceSession, object> SessionStatusChanged;
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs {
+ 	public IBuffer DeferredSessionInfo { get; }
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionErrorStatus {
+ 	Ok = 0,
+ 	Disassociated = 1,
+ 	LocalClose = 2,
+ 	RemoteClose = 3,
+ 	SystemFailure = 4,
+ 	NoResponseFromRemote = 5,
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequest {
+ 	public DeviceInformation DeviceInformation { get; }
+ 	public WiFiDirectServiceProvisioningInfo ProvisioningInfo { get; }
+ 	public void Close();
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs {
+ 	public WiFiDirectServiceSessionRequest GetSessionRequest();
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionStatus {
+ 	Closed = 0,
+ 	Initiated = 1,
+ 	Requested = 2,
+ 	Open = 3,
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceStatus {
+ 	Available = 0,
+ 	Busy = 1,
+ 	Custom = 2,
+ }


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

 new file: Windows 10/Windows.Foundation.winmd
 old file: Windows 8.1 Update/Windows.Foundation.winmd

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

+ public class Windows.Foundation.Collections.ValueSet {
+ 	public uint Size { get; }
+ 	public ValueSet();
+ 	public object Lookup( string returnValue );
+ 	public bool HasKey( string returnValue );
+ 	public IMapView<string, object> GetView();
+ 	public bool Insert( string returnValue, object key );
+ 	public void Remove( string key );
+ 	public void Clear();
+ 	public IIterator<IKeyValuePair<string, object>> First();
+ 	MapChangedEventHandler<string, object> MapChanged;
+ }

+ public class Windows.Foundation.Diagnostics.DiagnosticContext {
+ 	public bool IsEnabled { get; }
+ 	public IMapView<string, IDiagnosticProvider> Providers { get; }
+ 	public IDiagnosticTarget Target { get; }
+ 	public DiagnosticContext( IDiagnosticTarget diagnosticTarget );
+ 	public IDiagnosticProvider AddProvider( string value );
+ 	public void AddCustomProvider( IDiagnosticProvider provider );
+ 	public void Enable();
+ 	public void Disable();
+ }

+ public class Windows.Foundation.Diagnostics.DownloadInitiator {
+ 	public string FileName { get; }
+ 	public ulong LineNumber { get; }
+ 	public ulong LineOffset { get; }
+ 	public uint ProcessId { get; }
+ 	public uint ThreadId { get; }
+ }

+ public class Windows.Foundation.Diagnostics.HttpDiagnosticProvider {
+ 	public bool IsEnabled { get; }
+ 	public HttpDiagnosticProvider();
+ 	public void Initialize( DiagnosticContext session );
+ 	public void Enable();
+ 	public void Disable();
+ 	TypedEventHandler<HttpDiagnosticProvider, HttpDiagnosticProviderRequestRedirectedEventArgs> RequestRedirected;
+ 	TypedEventHandler<HttpDiagnosticProvider, HttpDiagnosticProviderRequestSentEventArgs> RequestSent;
+ 	TypedEventHandler<HttpDiagnosticProvider, HttpDiagnosticProviderResponseReceivedEventArgs> ResponseReceived;
+ }

+ public class Windows.Foundation.Diagnostics.HttpDiagnosticProviderRequestRedirectedEventArgs {
+ 	public Guid ActivityId { get; }
+ 	public string RedirectedUrl { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Foundation.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs {
+ 	public Guid ActivityId { get; }
+ 	public object Context { get; }
+ 	public HttpRequestMessage Message { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Foundation.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs {
+ 	public Guid ActivityId { get; }
+ 	public HttpResponseMessage Message { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public interface Windows.Foundation.Diagnostics.IDiagnosticProvider {
+ 	public bool IsEnabled { get; }
+ 	public void Initialize( DiagnosticContext session );
+ 	public void Enable();
+ 	public void Disable();
+ }

+ public interface Windows.Foundation.Diagnostics.IDiagnosticTarget {
+ }

+ public interface Windows.Foundation.Diagnostics.IProcessThreadId {
+ 	public uint ProcessId { get; }
+ 	public uint ThreadId { get; }
+ }

+ public class Windows.Foundation.Diagnostics.PackageDiagnosticTarget {
+ 	public string PackageId { get; }
+ 	public PackageDiagnosticTarget( string packageId );
+ }

+ public class Windows.Foundation.Diagnostics.ProcessDiagnosticTarget {
+ 	public uint ProcessId { get; }
+ 	public ProcessDiagnosticTarget( uint processId );
+ }

+ public class Windows.Foundation.Diagnostics.ProcessThreadId {
+ 	public uint ProcessId { get; }
+ 	public uint ThreadId { get; }
+ }

| public class Windows.Foundation.Metadata.ActivatableAttribute : System.Attribute {
+ 	public ActivatableAttribute( uint version, Type type );
+ 	public ActivatableAttribute( Type type, uint version, Type contractName );
| }

| public enum Windows.Foundation.Metadata.AttributeTargets {
+ 	ApiContract = 8192,
| }

| public class Windows.Foundation.Metadata.ComposableAttribute : System.Attribute {
+ 	public ComposableAttribute( Type type, CompositionType compositionType, uint version, Type contract );
| }

| public class Windows.Foundation.Metadata.DeprecatedAttribute : System.Attribute {
+ 	public DeprecatedAttribute( string message, DeprecationType type, uint version, Type contract );
| }

+ public class Windows.Foundation.Metadata.MetadataMarshalAttribute : System.Attribute {
+ 	public MetadataMarshalAttribute();
+ }

| public class Windows.Foundation.Metadata.StaticAttribute : System.Attribute {
+ 	public StaticAttribute( Type type, uint version, Type contractName );
| }

+ public struct Windows.Foundation.Numerics.Matrix3x2 {
+ 	public float M11;
+ 	public float M12;
+ 	public float M21;
+ 	public float M22;
+ 	public float M31;
+ 	public float M32;
+ }

+ public struct Windows.Foundation.Numerics.Matrix4x4 {
+ 	public float M11;
+ 	public float M12;
+ 	public float M13;
+ 	public float M14;
+ 	public float M21;
+ 	public float M22;
+ 	public float M23;
+ 	public float M24;
+ 	public float M31;
+ 	public float M32;
+ 	public float M33;
+ 	public float M34;
+ 	public float M41;
+ 	public float M42;
+ 	public float M43;
+ 	public float M44;
+ }

+ public struct Windows.Foundation.Numerics.Plane {
+ 	public Vector3 Normal;
+ 	public float D;
+ }

+ public struct Windows.Foundation.Numerics.Quaternion {
+ 	public float X;
+ 	public float Y;
+ 	public float Z;
+ 	public float W;
+ }

+ public struct Windows.Foundation.Numerics.Vector2 {
+ 	public float X;
+ 	public float Y;
+ }

+ public struct Windows.Foundation.Numerics.Vector3 {
+ 	public float X;
+ 	public float Y;
+ 	public float Z;
+ }

+ public struct Windows.Foundation.Numerics.Vector4 {
+ 	public float X;
+ 	public float Y;
+ 	public float Z;
+ 	public float W;
+ }


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

 new file: Windows 10/Windows.Globalization.winmd
 old file: Windows 8.1 Update/Windows.Globalization.winmd

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

| public class Windows.Globalization.NumeralSystemIdentifiers {
+ 	public string Brah { get; }
+ 	public string ZmthSans { get; }
+ 	public string MathBold { get; }
+ 	public string MathDbl { get; }
+ 	public string MathMono { get; }
+ 	public string MathSanb { get; }
+ 	public string MathSans { get; }
+ 	public string Osma { get; }
+ 	public string ZmthBold { get; }
+ 	public string ZmthDbl { get; }
+ 	public string ZmthMono { get; }
+ 	public string ZmthSanb { get; }
| }


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

 new file: Windows 10/Windows.Graphics.winmd
 old file: Windows 8.1 Update/Windows.Graphics.winmd

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

+ public enum Windows.Graphics.DirectX.DirectXPixelFormat {
+ 	Unknown = 0,
+ 	R32G32B32A32Typeless = 1,
+ 	R32G32B32A32Float = 2,
+ 	R32G32B32A32UInt = 3,
+ 	R32G32B32A32Int = 4,
+ 	R32G32B32Typeless = 5,
+ 	R32G32B32Float = 6,
+ 	R32G32B32UInt = 7,
+ 	R32G32B32Int = 8,
+ 	R16G16B16A16Typeless = 9,
+ 	R16G16B16A16Float = 10,
+ 	R16G16B16A16UIntNormalized = 11,
+ 	R16G16B16A16UInt = 12,
+ 	R16G16B16A16IntNormalized = 13,
+ 	R16G16B16A16Int = 14,
+ 	R32G32Typeless = 15,
+ 	R32G32Float = 16,
+ 	R32G32UInt = 17,
+ 	R32G32Int = 18,
+ 	R32G8X24Typeless = 19,
+ 	D32FloatS8X24UInt = 20,
+ 	R32FloatX8X24Typeless = 21,
+ 	X32TypelessG8X24UInt = 22,
+ 	R10G10B10A2Typeless = 23,
+ 	R10G10B10A2UIntNormalized = 24,
+ 	R10G10B10A2UInt = 25,
+ 	R11G11B10Float = 26,
+ 	R8G8B8A8Typeless = 27,
+ 	R8G8B8A8UIntNormalized = 28,
+ 	R8G8B8A8UIntNormalizedSrgb = 29,
+ 	R8G8B8A8UInt = 30,
+ 	R8G8B8A8IntNormalized = 31,
+ 	R8G8B8A8Int = 32,
+ 	R16G16Typeless = 33,
+ 	R16G16Float = 34,
+ 	R16G16UIntNormalized = 35,
+ 	R16G16UInt = 36,
+ 	R16G16IntNormalized = 37,
+ 	R16G16Int = 38,
+ 	R32Typeless = 39,
+ 	D32Float = 40,
+ 	R32Float = 41,
+ 	R32UInt = 42,
+ 	R32Int = 43,
+ 	R24G8Typeless = 44,
+ 	D24UIntNormalizedS8UInt = 45,
+ 	R24UIntNormalizedX8Typeless = 46,
+ 	X24TypelessG8UInt = 47,
+ 	R8G8Typeless = 48,
+ 	R8G8UIntNormalized = 49,
+ 	R8G8UInt = 50,
+ 	R8G8IntNormalized = 51,
+ 	R8G8Int = 52,
+ 	R16Typeless = 53,
+ 	R16Float = 54,
+ 	D16UIntNormalized = 55,
+ 	R16UIntNormalized = 56,
+ 	R16UInt = 57,
+ 	R16IntNormalized = 58,
+ 	R16Int = 59,
+ 	R8Typeless = 60,
+ 	R8UIntNormalized = 61,
+ 	R8UInt = 62,
+ 	R8IntNormalized = 63,
+ 	R8Int = 64,
+ 	A8UIntNormalized = 65,
+ 	R1UIntNormalized = 66,
+ 	R9G9B9E5SharedExponent = 67,
+ 	R8G8B8G8UIntNormalized = 68,
+ 	G8R8G8B8UIntNormalized = 69,
+ 	BC1Typeless = 70,
+ 	BC1UIntNormalized = 71,
+ 	BC1UIntNormalizedSrgb = 72,
+ 	BC2Typeless = 73,
+ 	BC2UIntNormalized = 74,
+ 	BC2UIntNormalizedSrgb = 75,
+ 	BC3Typeless = 76,
+ 	BC3UIntNormalized = 77,
+ 	BC3UIntNormalizedSrgb = 78,
+ 	BC4Typeless = 79,
+ 	BC4UIntNormalized = 80,
+ 	BC4IntNormalized = 81,
+ 	BC5Typeless = 82,
+ 	BC5UIntNormalized = 83,
+ 	BC5IntNormalized = 84,
+ 	B5G6R5UIntNormalized = 85,
+ 	B5G5R5A1UIntNormalized = 86,
+ 	B8G8R8A8UIntNormalized = 87,
+ 	B8G8R8X8UIntNormalized = 88,
+ 	R10G10B10XRBiasA2UIntNormalized = 89,
+ 	B8G8R8A8Typeless = 90,
+ 	B8G8R8A8UIntNormalizedSrgb = 91,
+ 	B8G8R8X8Typeless = 92,
+ 	B8G8R8X8UIntNormalizedSrgb = 93,
+ 	BC6HTypeless = 94,
+ 	BC6H16UnsignedFloat = 95,
+ 	BC6H16Float = 96,
+ 	BC7Typeless = 97,
+ 	BC7UIntNormalized = 98,
+ 	BC7UIntNormalizedSrgb = 99,
+ 	Ayuv = 100,
+ 	Y410 = 101,
+ 	Y416 = 102,
+ 	NV12 = 103,
+ 	P010 = 104,
+ 	P016 = 105,
+ 	Opaque420 = 106,
+ 	Yuy2 = 107,
+ 	Y210 = 108,
+ 	Y216 = 109,
+ 	NV11 = 110,
+ 	AI44 = 111,
+ 	IA44 = 112,
+ 	P8 = 113,
+ 	A8P8 = 114,
+ 	B4G4R4A4UIntNormalized = 115,
+ }

+ public enum Windows.Graphics.DirectX.Direct3D11.Direct3DBindings {
+ 	VertexBuffer = 1,
+ 	IndexBuffer = 2,
+ 	ConstantBuffer = 4,
+ 	ShaderResource = 8,
+ 	StreamOutput = 16,
+ 	RenderTarget = 32,
+ 	DepthStencil = 64,
+ 	UnorderedAccess = 128,
+ 	Decoder = 512,
+ 	VideoEncoder = 1024,
+ }

+ public class Windows.Graphics.DirectX.Direct3D11.Direct3DDevice {
+ 	public void Trim();
+ 	public void Close();
+ }

+ public struct Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription {
+ 	public int Count;
+ 	public int Quality;
+ }

+ public class Windows.Graphics.DirectX.Direct3D11.Direct3DSurface {
+ 	public Direct3DSurfaceDescription Description { get; }
+ 	public void Close();
+ }

+ public struct Windows.Graphics.DirectX.Direct3D11.Direct3DSurfaceDescription {
+ 	public int Width;
+ 	public int Height;
+ 	public DirectXPixelFormat Format;
+ 	public Direct3DMultisampleDescription MultisampleDescription;
+ }

+ public enum Windows.Graphics.DirectX.Direct3D11.Direct3DUsage {
+ 	Default = 0,
+ 	Immutable = 1,
+ 	Dynamic = 2,
+ 	Staging = 3,
+ }

+ public class Windows.Graphics.Imaging.BitmapBuffer {
+ 	public uint Length { get; set; }
+ 	public uint Capacity { get; }
+ 	public int GetPlaneCount();
+ 	public BitmapPlaneDescription GetPlaneDescription( int value );
+ 	public void Close();
+ }

+ public enum Windows.Graphics.Imaging.BitmapBufferAccessMode {
+ 	Read = 0,
+ 	ReadWrite = 1,
+ 	Write = 2,
+ }

| public class Windows.Graphics.Imaging.BitmapDecoder {
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync();
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat );
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat, BitmapTransform alphaMode, ExifOrientationMode transform, ColorManagementMode exifOrientationMode );
| }

| public class Windows.Graphics.Imaging.BitmapEncoder {
+ 	public void SetSoftwareBitmap( SoftwareBitmap bitmap );
| }

| public class Windows.Graphics.Imaging.BitmapFrame {
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync();
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat );
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat, BitmapTransform alphaMode, ExifOrientationMode transform, ColorManagementMode exifOrientationMode );
| }

| public enum Windows.Graphics.Imaging.BitmapPixelFormat {
+ 	Nv12 = 103,
+ 	Yuy2 = 107,
| }

+ public struct Windows.Graphics.Imaging.BitmapPlaneDescription {
+ 	public int StartIndex;
+ 	public int Width;
+ 	public int Height;
+ 	public int Stride;
+ }

+ public interface Windows.Graphics.Imaging.IBitmapFrameWithSoftwareBitmap {
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync();
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat );
+ 	public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat, BitmapTransform alphaMode, ExifOrientationMode transform, ColorManagementMode exifOrientationMode );
+ }

+ public class Windows.Graphics.Imaging.SoftwareBitmap {
+ 	public double DpiY { get; set; }
+ 	public double DpiX { get; set; }
+ 	public BitmapAlphaMode BitmapAlphaMode { get; }
+ 	public BitmapPixelFormat BitmapPixelFormat { get; }
+ 	public bool IsReadOnly { get; }
+ 	public int PixelHeight { get; }
+ 	public int PixelWidth { get; }
+ 	public SoftwareBitmap( BitmapPixelFormat format, int width, int height );
+ 	public SoftwareBitmap( BitmapPixelFormat format, int width, int height, BitmapAlphaMode alpha );
+ 	public BitmapBuffer LockBuffer( BitmapBufferAccessMode value );
+ 	public void CopyTo( SoftwareBitmap bitmap );
+ 	public void CopyFromBuffer( IBuffer buffer );
+ 	public void CopyToBuffer( IBuffer buffer );
+ 	public SoftwareBitmap GetReadOnlyView();
+ 	public void Close();
+ 	public static SoftwareBitmap Copy( SoftwareBitmap value );
+ 	public static SoftwareBitmap Convert( SoftwareBitmap value, BitmapPixelFormat source );
+ 	public static SoftwareBitmap Convert( SoftwareBitmap value, BitmapPixelFormat source, BitmapAlphaMode format );
+ 	public static SoftwareBitmap CreateCopyFromBuffer( IBuffer value, BitmapPixelFormat source, int format, int width );
+ 	public static SoftwareBitmap CreateCopyFromBuffer( IBuffer value, BitmapPixelFormat source, int format, int width, BitmapAlphaMode height );
+ 	public static IAsyncOperation<SoftwareBitmap> CreateCopyFromSurfaceAsync( Direct3DSurface value );
+ 	public static IAsyncOperation<SoftwareBitmap> CreateCopyFromSurfaceAsync( Direct3DSurface value, BitmapAlphaMode surface );
+ }


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

 new file: Windows 10/Windows.Management.winmd
 old file: Windows 8.1 Update/Windows.Management.winmd

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

| public class Windows.Management.Deployment.PackageManager {
+ 	public IAsyncOperation<PackageVolume> AddPackageVolumeAsync( string packageVolume );
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync( Uri deploymentOperation, IIterable<Uri> packageUri, DeploymentOptions dependencyPackageUris, PackageVolume deploymentOptions );
+ 	public void ClearPackageStatus( string packageFullName, PackageStatus status );
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RegisterPackageAsync( Uri deploymentOperation, IIterable<Uri> manifestUri, DeploymentOptions dependencyPackageUris, PackageVolume deploymentOptions );
+ 	public PackageVolume FindPackageVolume( string volume );
+ 	public IIterable<PackageVolume> FindPackageVolumes();
+ 	public PackageVolume GetDefaultPackageVolume();
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> MovePackageToVolumeAsync( string deploymentOperation, DeploymentOptions packageFullName, PackageVolume deploymentOptions );
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RemovePackageVolumeAsync( PackageVolume deploymentOperation );
+ 	public void SetDefaultPackageVolume( PackageVolume volume );
+ 	public void SetPackageStatus( string packageFullName, PackageStatus status );
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> SetPackageVolumeOfflineAsync( PackageVolume deploymentOperation );
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> SetPackageVolumeOnlineAsync( PackageVolume deploymentOperation );
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync( Uri deploymentOperation, IIterable<Uri> packageUri, DeploymentOptions dependencyPackageUris, PackageVolume deploymentOptions );
+ 	public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StageUserDataAsync( string deploymentOperation, DeploymentOptions packageFullName );
| }

+ public enum Windows.Management.Deployment.PackageStatus {
+ 	OK = 0,
+ 	LicenseIssue = 1,
+ 	Modified = 2,
+ 	Tampered = 4,
+ 	Disabled = 8,
+ 	PackageOffline = 16,
+ 	DataOffline = 32,
+ }

+ public class Windows.Management.Deployment.PackageVolume {
+ 	public bool IsOffline { get; }
+ 	public bool IsSystemVolume { get; }
+ 	public string MountPoint { get; }
+ 	public string Name { get; }
+ 	public string PackageStorePath { get; }
+ 	public bool SupportsHardLinks { get; }
+ 	public PackageVolume();
+ 	public IIterable<Package> FindPackages();
+ 	public IIterable<Package> FindPackages( string packageCollection, string packageName );
+ 	public IIterable<Package> FindPackages( string packageCollection );
+ 	public IIterable<Package> FindPackagesWithPackageTypes( PackageTypes packageCollection );
+ 	public IIterable<Package> FindPackagesWithPackageTypes( string packageCollection, string packageName, PackageTypes packagePublisher );
+ 	public IIterable<Package> FindPackagesWithPackageTypes( string packageCollection, PackageTypes packageFamilyName );
+ 	public IIterable<Package> FindPackage( string packageCollection );
+ 	public IIterable<Package> FindPackagesForUser( string packageCollection );
+ 	public IIterable<Package> FindPackagesForUser( string packageCollection, string userSecurityId, string packageName );
+ 	public IIterable<Package> FindPackagesForUser( string packageCollection, string userSecurityId );
+ 	public IIterable<Package> FindPackagesForUserWithPackageTypes( string packageCollection, PackageTypes userSecurityId );
+ 	public IIterable<Package> FindPackagesForUserWithPackageTypes( string packageCollection, string userSecurityId, string packageName, PackageTypes packagePublisher );
+ 	public IIterable<Package> FindPackagesForUserWithPackageTypes( string packageCollection, string userSecurityId, PackageTypes packageFamilyName );
+ 	public IIterable<Package> FindPackageForUser( string packageCollection, string userSecurityId );
+ }


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

 new file: Windows 10/Windows.Media.winmd
 old file: Windows 8.1 Update/Windows.Media.winmd

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

+ public class Windows.Media.AudioBuffer {
+ 	public uint Length { get; set; }
+ 	public uint Capacity { get; }
+ 	public void Close();
+ }

+ public enum Windows.Media.AudioBufferAccessMode {
+ 	Read = 0,
+ 	ReadWrite = 1,
+ 	Write = 2,
+ }

+ public class Windows.Media.AudioFrame {
+ 	public IReference<TimeSpan> SystemRelativeTime { get; set; }
+ 	public IReference<TimeSpan> RelativeTime { get; set; }
+ 	public bool IsDiscontinuous { get; set; }
+ 	public IReference<TimeSpan> Duration { get; set; }
+ 	public IPropertySet ExtendedProperties { get; }
+ 	public bool IsReadOnly { get; }
+ 	public string Type { get; }
+ 	public AudioFrame( uint capacity );
+ 	public AudioBuffer LockBuffer( AudioBufferAccessMode value );
+ 	public void Close();
+ }

+ public interface Windows.Media.IMediaFrame {
+ 	public IReference<TimeSpan> Duration { get; set; }
+ 	public IPropertySet ExtendedProperties { get; }
+ 	public bool IsDiscontinuous { get; set; }
+ 	public bool IsReadOnly { get; }
+ 	public IReference<TimeSpan> RelativeTime { get; set; }
+ 	public IReference<TimeSpan> SystemRelativeTime { get; set; }
+ 	public string Type { get; }
+ }

+ public class Windows.Media.VideoFrame {
+ 	public Direct3DSurface Direct3DSurface { get; }
+ 	public SoftwareBitmap SoftwareBitmap { get; }
+ 	public IReference<TimeSpan> SystemRelativeTime { get; set; }
+ 	public IReference<TimeSpan> RelativeTime { get; set; }
+ 	public bool IsDiscontinuous { get; set; }
+ 	public IReference<TimeSpan> Duration { get; set; }
+ 	public IPropertySet ExtendedProperties { get; }
+ 	public bool IsReadOnly { get; }
+ 	public string Type { get; }
+ 	public VideoFrame( BitmapPixelFormat format, int width, int height );
+ 	public VideoFrame( BitmapPixelFormat format, int width, int height, BitmapAlphaMode alpha );
+ 	public IAsyncAction CopyToAsync( VideoFrame value );
+ 	public void Close();
+ }

| public class Windows.Media.Capture.CapturedFrame {
+ 	public SoftwareBitmap SoftwareBitmap { get; }
| }

+ public class Windows.Media.Capture.CapturedFrameControlValues {
+ 	public IReference<TimeSpan> Exposure { get; }
+ 	public IReference<float> ExposureCompensation { get; }
+ 	public IReference<float> FlashPowerPercent { get; }
+ 	public IReference<bool> Flashed { get; }
+ 	public IReference<uint> Focus { get; }
+ 	public IReference<uint> IsoSpeed { get; }
+ 	public IReference<CaptureSceneMode> SceneMode { get; }
+ 	public IReference<uint> WhiteBalance { get; }
+ 	public IReference<float> ZoomFactor { get; }
+ 	public IReference<MediaCaptureFocusState> FocusState { get; }
+ 	public IReference<double> IsoAnalogGain { get; }
+ 	public IReference<double> IsoDigitalGain { get; }
+ 	public MediaRatio SensorFrameRate { get; }
+ 	public IReference<WhiteBalanceGain> WhiteBalanceGain { get; }
+ }

| public class Windows.Media.Capture.MediaCapture {
+ 	public IAsyncOperation<VariablePhotoSequenceCapture> PrepareVariablePhotoSequenceCaptureAsync( ImageEncodingProperties operation );
+ 	public IAsyncOperation<IMediaExtension> AddAudioEffectAsync( IAudioEffectDefinition op );
+ 	public IAsyncOperation<IMediaExtension> AddVideoEffectAsync( IVideoEffectDefinition op, MediaStreamType definition );
| }

+ public class Windows.Media.Capture.MediaCaptureFocusChangedEventArgs {
+ 	public MediaCaptureFocusState FocusState { get; }
+ }

| public class Windows.Media.Capture.MediaCaptureInitializationSettings {
+ 	public IMediaSource VideoSource { get; set; }
+ 	public IMediaSource AudioSource { get; set; }
| }

+ public class Windows.Media.Capture.PhotoConfirmationCapturedEventArgs {
+ 	public TimeSpan CaptureTimeOffset { get; }
+ 	public CapturedFrame Frame { get; }
+ }

+ public struct Windows.Media.Capture.WhiteBalanceGain {
+ 	public double R;
+ 	public double G;
+ 	public double B;
+ }

+ public class Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs {
+ 	public TimeSpan CaptureTimeOffset { get; }
+ 	public CapturedFrameControlValues CapturedFrameControlValues { get; }
+ 	public CapturedFrame Frame { get; }
+ 	public IReference<uint> UsedFrameControllerIndex { get; }
+ }

+ public class Windows.Media.Capture.Core.VariablePhotoSequenceCapture {
+ 	public IAsyncAction StartAsync();
+ 	public IAsyncAction StopAsync();
+ 	public IAsyncAction FinishAsync();
+ 	public IAsyncAction UpdateSettingsAsync();
+ 	TypedEventHandler<VariablePhotoSequenceCapture, VariablePhotoCapturedEventArgs> PhotoCaptured;
+ 	TypedEventHandler<VariablePhotoSequenceCapture, object> Stopped;
+ }

+ public class Windows.Media.Core.DetectedFace {
+ 	public Rect Bounds { get; }
+ 	public double Certainty { get; }
+ }

+ public class Windows.Media.Core.FaceDetectedEventArgs {
+ 	public FaceDetectionEffectFrame ResultFrame { get; }
+ }

+ public class Windows.Media.Core.FaceDetectionEffect {
+ 	public uint MaxFacesToDetect { get; set; }
+ 	public bool Enabled { get; set; }
+ 	public TimeSpan DesiredDetectionPeriod { get; set; }
+ 	public uint MaxFacesSupported { get; }
+ 	public void SetProperties( IPropertySet configuration );
+ 	TypedEventHandler<FaceDetectionEffect, FaceDetectedEventArgs> FaceDetected;
+ }

+ public class Windows.Media.Core.FaceDetectionEffectDefinition {
+ 	public bool SynchronousDetectionEnabled { get; set; }
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ 	public FaceDetectionEffectDefinition();
+ }

+ public class Windows.Media.Core.FaceDetectionEffectFrame {
+ 	public IReference<TimeSpan> SystemRelativeTime { get; set; }
+ 	public IReference<TimeSpan> RelativeTime { get; set; }
+ 	public bool IsDiscontinuous { get; set; }
+ 	public IReference<TimeSpan> Duration { get; set; }
+ 	public IPropertySet ExtendedProperties { get; }
+ 	public bool IsReadOnly { get; }
+ 	public string Type { get; }
+ 	public IVectorView<DetectedFace> Faces { get; }
+ 	public void Close();
+ }

+ public class Windows.Media.Core.FlashTechniqueControl {
+ 	public bool FrameControllersEnabled { get; set; }
+ 	public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.FlashTechniqueOutput {
+ 	public double Certainty { get; }
+ 	public IVectorView<FrameController> FrameControllers { get; }
+ }

+ public class Windows.Media.Core.HazeControl {
+ 	public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.HazeOutput {
+ 	public double Certainty { get; }
+ }

+ public class Windows.Media.Core.HighDynamicRangeControl {
+ 	public bool FrameControllersEnabled { get; set; }
+ 	public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.HighDynamicRangeOutput {
+ 	public double Certainty { get; }
+ 	public IVectorView<FrameController> FrameControllers { get; }
+ }

+ public class Windows.Media.Core.LowLightControl {
+ 	public bool FrameControllersEnabled { get; set; }
+ 	public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.LowLightOutput {
+ 	public double Certainty { get; }
+ 	public IVectorView<FrameController> FrameControllers { get; }
+ }

+ public enum Windows.Media.Core.MseAppendMode {
+ 	Segments = 0,
+ 	Sequence = 1,
+ }

+ public enum Windows.Media.Core.MseEndOfStreamStatus {
+ 	Success = 0,
+ 	NetworkError = 1,
+ 	DecodeError = 2,
+ 	UnknownError = 3,
+ }

+ public enum Windows.Media.Core.MseReadyState {
+ 	Closed = 0,
+ 	Open = 1,
+ 	Ended = 2,
+ }

+ public class Windows.Media.Core.MseSourceBuffer {
+ 	public TimeSpan TimestampOffset { get; set; }
+ 	public MseAppendMode Mode { get; set; }
+ 	public TimeSpan AppendWindowStart { get; set; }
+ 	public TimeSpan AppendWindowEnd { get; set; }
+ 	public IVectorView<MseTimeRange> Buffered { get; }
+ 	public bool Updating { get; }
+ 	public void AppendBuffer( IBuffer buffer );
+ 	public void AppendStream( IInputStream stream );
+ 	public void AppendStream( IInputStream stream, ulong maxSize );
+ 	public void Abort();
+ 	public void Remove( TimeSpan start, TimeSpan end );
+ 	TypedEventHandler<MseSourceBuffer, object> Aborted;
+ 	TypedEventHandler<MseSourceBuffer, object> Error;
+ 	TypedEventHandler<MseSourceBuffer, object> UpdateEnded;
+ 	TypedEventHandler<MseSourceBuffer, object> UpdateStarting;
+ 	TypedEventHandler<MseSourceBuffer, object> Updated;
+ }

+ public class Windows.Media.Core.MseSourceBufferList {
+ 	public IVectorView<MseSourceBuffer> Buffers { get; }
+ 	TypedEventHandler<MseSourceBufferList, object> SourceBufferAdded;
+ 	TypedEventHandler<MseSourceBufferList, object> SourceBufferRemoved;
+ }

+ public class Windows.Media.Core.MseStreamSource {
+ 	public TimeSpan Duration { get; set; }
+ 	public MseSourceBufferList ActiveSourceBuffers { get; }
+ 	public MseReadyState ReadyState { get; }
+ 	public MseSourceBufferList SourceBuffers { get; }
+ 	public MseStreamSource();
+ 	public MseSourceBuffer AddSourceBuffer( string buffer );
+ 	public void RemoveSourceBuffer( MseSourceBuffer buffer );
+ 	public void EndOfStream( MseEndOfStreamStatus status );
+ 	public static bool IsContentTypeSupported( string value );
+ 	TypedEventHandler<MseStreamSource, object> Closed;
+ 	TypedEventHandler<MseStreamSource, object> Ended;
+ 	TypedEventHandler<MseStreamSource, object> Opened;
+ }

+ public struct Windows.Media.Core.MseTimeRange {
+ 	public TimeSpan Start;
+ 	public TimeSpan End;
+ }

+ public class Windows.Media.Core.SceneAnalysisEffect {
+ 	public TimeSpan DesiredAnalysisPeriod { get; set; }
+ 	public FlashTechniqueControl FlashTechniqueAnalyzer { get; }
+ 	public HazeControl HazeAnalyzer { get; }
+ 	public HighDynamicRangeControl HighDynamicRangeAnalyzer { get; }
+ 	public LowLightControl LowLightAnalyzer { get; }
+ 	public void SetProperties( IPropertySet configuration );
+ 	TypedEventHandler<SceneAnalysisEffect, SceneAnalyzedEventArgs> SceneAnalyzed;
+ }

+ public class Windows.Media.Core.SceneAnalysisEffectDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ 	public SceneAnalysisEffectDefinition();
+ }

+ public class Windows.Media.Core.SceneAnalysisEffectFrame {
+ 	public IReference<TimeSpan> SystemRelativeTime { get; set; }
+ 	public IReference<TimeSpan> RelativeTime { get; set; }
+ 	public bool IsDiscontinuous { get; set; }
+ 	public IReference<TimeSpan> Duration { get; set; }
+ 	public IPropertySet ExtendedProperties { get; }
+ 	public bool IsReadOnly { get; }
+ 	public string Type { get; }
+ 	public FlashTechniqueOutput FlashTechnique { get; }
+ 	public CapturedFrameControlValues FrameControlValues { get; }
+ 	public HazeOutput Haze { get; }
+ 	public HighDynamicRangeOutput HighDynamicRange { get; }
+ 	public LowLightOutput LowLight { get; }
+ 	public void Close();
+ }

+ public class Windows.Media.Core.SceneAnalyzedEventArgs {
+ 	public SceneAnalysisEffectFrame ResultFrame { get; }
+ }

+ public class Windows.Media.Core.VideoStabilizationEffect {
+ 	public bool Enabled { get; set; }
+ 	public IAsyncOperation<MediaEncodingProfile> ConfigureEncodingProfileAsync( VideoDeviceController asyncInfo, MediaEncodingProfile controller );
+ 	public void SetProperties( IPropertySet configuration );
+ }

+ public class Windows.Media.Core.VideoStabilizationEffectDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ 	public VideoStabilizationQualityMode QualityMode { get; set; }
+ 	public bool LowLatencyEnabled { get; set; }
+ 	public VideoStabilizationEffectDefinition();
+ }

+ public enum Windows.Media.Core.VideoStabilizationQualityMode {
+ 	HighPerformance = 0,
+ 	Balanced = 1,
+ 	HighQuality = 2,
+ }

+ public enum Windows.Media.Devices.AutoFocusRange {
+ 	FullRange = 0,
+ 	Macro = 1,
+ 	Normal = 2,
+ }

+ public class Windows.Media.Devices.ExposurePriorityVideoControl {
+ 	public bool Enabled { get; set; }
+ 	public bool Supported { get; }
+ }

| public class Windows.Media.Devices.FlashControl {
+ 	public bool AssistantLightEnabled { get; set; }
+ 	public bool AssistantLightSupported { get; }
| }

| public class Windows.Media.Devices.FocusControl {
+ 	public bool FocusChangedSupported { get; }
+ 	public MediaCaptureFocusState FocusState { get; }
+ 	public FocusMode Mode { get; }
+ 	public IVectorView<ManualFocusDistance> SupportedFocusDistances { get; }
+ 	public IVectorView<FocusMode> SupportedFocusModes { get; }
+ 	public IVectorView<AutoFocusRange> SupportedFocusRanges { get; }
+ 	public bool WaitForFocusSupported { get; }
+ 	public IAsyncAction UnlockAsync();
+ 	public IAsyncAction LockAsync();
+ 	public void Configure( FocusSettings settings );
| }

+ public enum Windows.Media.Devices.FocusMode {
+ 	Auto = 0,
+ 	Single = 1,
+ 	Continuous = 2,
+ 	Manual = 3,
+ }

+ public class Windows.Media.Devices.FocusSettings {
+ 	public bool WaitForFocus { get; set; }
+ 	public IReference<uint> Value { get; set; }
+ 	public FocusMode Mode { get; set; }
+ 	public IReference<ManualFocusDistance> Distance { get; set; }
+ 	public bool DisableDriverFallback { get; set; }
+ 	public AutoFocusRange AutoFocusRange { get; set; }
+ 	public FocusSettings();
+ }

| public class Windows.Media.Devices.IsoSpeedControl {
+ 	public bool Auto { get; }
+ 	public uint Max { get; }
+ 	public uint Min { get; }
+ 	public uint Step { get; }
+ 	public uint Value { get; }
+ 	public IAsyncAction SetValueAsync( uint asyncInfo );
+ 	public IAsyncAction SetAutoAsync();
| }

+ public enum Windows.Media.Devices.ManualFocusDistance {
+ 	Infinity = 0,
+ 	Hyperfocal = 1,
+ 	Nearest = 2,
+ }

+ public enum Windows.Media.Devices.MediaCaptureFocusState {
+ 	Uninitialized = 0,
+ 	Lost = 1,
+ 	Searching = 2,
+ 	Focused = 3,
+ 	Failed = 4,
+ }

+ public class Windows.Media.Devices.PhotoConfirmationControl {
+ 	public MediaPixelFormat PixelFormat { get; set; }
+ 	public bool Enabled { get; set; }
+ 	public bool Supported { get; }
+ }

| public class Windows.Media.Devices.RegionOfInterest {
+ 	public uint Weight { get; set; }
+ 	public RegionOfInterestType Type { get; set; }
+ 	public bool BoundsNormalized { get; set; }
| }

+ public enum Windows.Media.Devices.RegionOfInterestType {
+ 	Unknown = 0,
+ 	Face = 1,
+ }

| public class Windows.Media.Devices.VideoDeviceController {
+ 	public PhotoConfirmationControl PhotoConfirmationControl { get; }
+ 	public VariablePhotoSequenceController VariablePhotoSequenceController { get; }
+ 	public ZoomControl ZoomControl { get; }
+ 	public ExposurePriorityVideoControl ExposurePriorityVideoControl { get; }
| }

+ public class Windows.Media.Devices.ZoomControl {
+ 	public float Value { get; set; }
+ 	public float Max { get; }
+ 	public float Min { get; }
+ 	public float Step { get; }
+ 	public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameControlCapabilities {
+ 	public FrameExposureCapabilities Exposure { get; }
+ 	public FrameExposureCompensationCapabilities ExposureCompensation { get; }
+ 	public FrameFocusCapabilities Focus { get; }
+ 	public FrameIsoSpeedCapabilities IsoSpeed { get; }
+ 	public bool PhotoConfirmationSupported { get; }
+ 	public FrameFlashCapabilities Flash { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameController {
+ 	public FrameFlashControl FlashControl { get; }
+ 	public IReference<bool> PhotoConfirmationEnabled { get; set; }
+ 	public FrameExposureCompensationControl ExposureCompensationControl { get; }
+ 	public FrameExposureControl ExposureControl { get; }
+ 	public FrameFocusControl FocusControl { get; }
+ 	public FrameIsoSpeedControl IsoSpeedControl { get; }
+ 	public FrameController();
+ }

+ public class Windows.Media.Devices.Core.FrameExposureCapabilities {
+ 	public TimeSpan Max { get; }
+ 	public TimeSpan Min { get; }
+ 	public TimeSpan Step { get; }
+ 	public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameExposureCompensationCapabilities {
+ 	public float Max { get; }
+ 	public float Min { get; }
+ 	public float Step { get; }
+ 	public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameExposureCompensationControl {
+ 	public IReference<float> Value { get; set; }
+ }

+ public class Windows.Media.Devices.Core.FrameExposureControl {
+ 	public IReference<TimeSpan> Value { get; set; }
+ 	public bool Auto { get; set; }
+ }

+ public class Windows.Media.Devices.Core.FrameFlashCapabilities {
+ 	public bool PowerSupported { get; }
+ 	public bool RedEyeReductionSupported { get; }
+ 	public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameFlashControl {
+ 	public bool RedEyeReduction { get; set; }
+ 	public float PowerPercent { get; set; }
+ 	public FrameFlashMode Mode { get; set; }
+ 	public bool Auto { get; set; }
+ }

+ public enum Windows.Media.Devices.Core.FrameFlashMode {
+ 	Disable = 0,
+ 	Enable = 1,
+ 	Global = 2,
+ }

+ public class Windows.Media.Devices.Core.FrameFocusCapabilities {
+ 	public uint Max { get; }
+ 	public uint Min { get; }
+ 	public uint Step { get; }
+ 	public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameFocusControl {
+ 	public IReference<uint> Value { get; set; }
+ }

+ public class Windows.Media.Devices.Core.FrameIsoSpeedCapabilities {
+ 	public uint Max { get; }
+ 	public uint Min { get; }
+ 	public uint Step { get; }
+ 	public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameIsoSpeedControl {
+ 	public IReference<uint> Value { get; set; }
+ 	public bool Auto { get; set; }
+ }

+ public class Windows.Media.Devices.Core.VariablePhotoSequenceController {
+ 	public float PhotosPerSecondLimit { get; set; }
+ 	public IVector<FrameController> DesiredFrameControllers { get; }
+ 	public FrameControlCapabilities FrameCapabilities { get; }
+ 	public float MaxPhotosPerSecond { get; }
+ 	public bool Supported { get; }
+ 	public MediaRatio GetHighestConcurrentFrameRate( IMediaEncodingProperties value );
+ 	public MediaRatio GetCurrentFrameRate();
+ }

+ public class Windows.Media.Editing.BackgroundAudioTrack {
+ 	public double Volume { get; set; }
+ 	public TimeSpan TrimTimeFromStart { get; set; }
+ 	public TimeSpan TrimTimeFromEnd { get; set; }
+ 	public TimeSpan Delay { get; set; }
+ 	public IVector<IAudioEffectDefinition> AudioEffectDefinitions { get; }
+ 	public TimeSpan OriginalDuration { get; }
+ 	public TimeSpan TrimmedDuration { get; }
+ 	public IMap<string, string> UserData { get; }
+ 	public BackgroundAudioTrack Clone();
+ 	public AudioEncodingProperties GetAudioEncodingProperties();
+ 	public static BackgroundAudioTrack CreateFromEmbeddedAudioTrack( EmbeddedAudioTrack value );
+ 	public static IAsyncOperation<BackgroundAudioTrack> CreateFromFileAsync( IStorageFile operation );
+ }

+ public class Windows.Media.Editing.EmbeddedAudioTrack {
+ 	public AudioEncodingProperties GetAudioEncodingProperties();
+ }

+ public class Windows.Media.Editing.MediaClip {
+ 	public double Volume { get; set; }
+ 	public TimeSpan TrimTimeFromStart { get; set; }
+ 	public TimeSpan TrimTimeFromEnd { get; set; }
+ 	public uint SelectedEmbeddedAudioTrackIndex { get; set; }
+ 	public IVector<IAudioEffectDefinition> AudioEffectDefinitions { get; }
+ 	public IVectorView<EmbeddedAudioTrack> EmbeddedAudioTracks { get; }
+ 	public TimeSpan EndTimeInComposition { get; }
+ 	public TimeSpan OriginalDuration { get; }
+ 	public TimeSpan StartTimeInComposition { get; }
+ 	public TimeSpan TrimmedDuration { get; }
+ 	public IMap<string, string> UserData { get; }
+ 	public IVector<IVideoEffectDefinition> VideoEffectDefinitions { get; }
+ 	public MediaClip Clone();
+ 	public VideoEncodingProperties GetVideoEncodingProperties();
+ 	public static MediaClip CreateFromSurface( Direct3DSurface value, TimeSpan surface );
+ 	public static MediaClip CreateFromColor( Color value, TimeSpan color );
+ 	public static IAsyncOperation<MediaClip> CreateFromFileAsync( IStorageFile operation );
+ 	public static IAsyncOperation<MediaClip> CreateFromImageFileAsync( IStorageFile operation, TimeSpan file );
+ }

+ public class Windows.Media.Editing.MediaComposition {
+ 	public IVector<MediaOverlayLayer> OverlayLayers { get; }
+ 	public IVector<BackgroundAudioTrack> BackgroundAudioTracks { get; }
+ 	public IVector<MediaClip> Clips { get; }
+ 	public TimeSpan Duration { get; }
+ 	public IMap<string, string> UserData { get; }
+ 	public MediaComposition();
+ 	public MediaComposition Clone();
+ 	public IAsyncAction SaveAsync( IStorageFile operation );
+ 	public IAsyncOperation<ImageStream> GetThumbnailAsync( TimeSpan operation, int timeFromStart, int scaledWidth, VideoFramePrecision scaledHeight );
+ 	public IAsyncOperation<IVectorView<ImageStream>> GetThumbnailsAsync( IIterable<TimeSpan> operation, int timesFromStart, int scaledWidth, VideoFramePrecision scaledHeight );
+ 	public IAsyncOperationWithProgress<TranscodeFailureReason, double> RenderToFileAsync( IStorageFile operation );
+ 	public IAsyncOperationWithProgress<TranscodeFailureReason, double> RenderToFileAsync( IStorageFile operation, MediaTrimmingPreference destination );
+ 	public IAsyncOperationWithProgress<TranscodeFailureReason, double> RenderToFileAsync( IStorageFile operation, MediaTrimmingPreference destination, MediaEncodingProfile trimmingPreference );
+ 	public MediaEncodingProfile CreateDefaultEncodingProfile();
+ 	public MediaStreamSource GenerateMediaStreamSource();
+ 	public MediaStreamSource GenerateMediaStreamSource( MediaEncodingProfile value );
+ 	public MediaStreamSource GeneratePreviewMediaStreamSource( int value, int scaledWidth );
+ 	public static IAsyncOperation<MediaComposition> LoadAsync( StorageFile operation );
+ }

+ public class Windows.Media.Editing.MediaOverlay {
+ 	public Rect Position { get; set; }
+ 	public double Opacity { get; set; }
+ 	public TimeSpan Delay { get; set; }
+ 	public MediaClip Clip { get; }
+ 	public MediaOverlay( MediaClip clip );
+ 	public MediaOverlay( MediaClip clip, Rect position, double opacity );
+ 	public MediaOverlay Clone();
+ }

+ public class Windows.Media.Editing.MediaOverlayLayer {
+ 	public IVideoCompositorDefinition CustomCompositorDefinition { get; }
+ 	public IVector<MediaOverlay> Overlays { get; }
+ 	public MediaOverlayLayer( IVideoCompositorDefinition compositorDefinition );
+ 	public MediaOverlayLayer();
+ 	public MediaOverlayLayer Clone();
+ }

+ public enum Windows.Media.Editing.MediaTrimmingPreference {
+ 	Fast = 0,
+ 	Precise = 1,
+ }

+ public enum Windows.Media.Editing.VideoFramePrecision {
+ 	NearestFrame = 0,
+ 	NearestKeyFrame = 1,
+ }

+ public class Windows.Media.Effects.AudioEffectDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ 	public AudioEffectDefinition( string activatableClassId );
+ 	public AudioEffectDefinition( string activatableClassId, IPropertySet props );
+ }

+ public class Windows.Media.Effects.CompositeVideoFrameContext {
+ 	public VideoFrame BackgroundFrame { get; }
+ 	public VideoFrame OutputFrame { get; }
+ 	public IVectorView<Direct3DSurface> SurfacesToOverlay { get; }
+ 	public MediaOverlay GetOverlayForSurface( Direct3DSurface value );
+ }

+ public interface Windows.Media.Effects.IAudioEffectDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ }

+ public interface Windows.Media.Effects.IBasicAudioEffect {
+ 	public IVectorView<AudioEncodingProperties> SupportedEncodingProperties { get; }
+ 	public bool UseInputFrameForOutput { get; }
+ 	public void SetEncodingProperties( AudioEncodingProperties encodingProperties );
+ 	public void ProcessFrame( ProcessAudioFrameContext context );
+ 	public void Close( MediaEffectClosedReason reason );
+ 	public void DiscardQueuedFrames();
+ }

+ public interface Windows.Media.Effects.IBasicVideoEffect {
+ 	public bool IsReadOnly { get; }
+ 	public IVectorView<VideoEncodingProperties> SupportedEncodingProperties { get; }
+ 	public MediaMemoryTypes SupportedMemoryTypes { get; }
+ 	public bool TimeIndependent { get; }
+ 	public void SetEncodingProperties( VideoEncodingProperties encodingProperties, Direct3DDevice device );
+ 	public void ProcessFrame( ProcessVideoFrameContext context );
+ 	public void Close( MediaEffectClosedReason reason );
+ 	public void DiscardQueuedFrames();
+ }

+ public interface Windows.Media.Effects.IVideoCompositor {
+ 	public bool TimeIndependent { get; }
+ 	public void SetEncodingProperties( VideoEncodingProperties backgroundProperties, Direct3DDevice device );
+ 	public void CompositeFrame( CompositeVideoFrameContext context );
+ 	public void Close( MediaEffectClosedReason reason );
+ 	public void DiscardQueuedFrames();
+ }

+ public interface Windows.Media.Effects.IVideoCompositorDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ }

+ public interface Windows.Media.Effects.IVideoEffectDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ }

+ public enum Windows.Media.Effects.MediaEffectClosedReason {
+ 	Done = 0,
+ 	UnknownError = 1,
+ 	UnsupportedEncodingFormat = 2,
+ 	EffectCurrentlyUnloaded = 3,
+ }

+ public enum Windows.Media.Effects.MediaMemoryTypes {
+ 	Gpu = 0,
+ 	Cpu = 1,
+ 	GpuAndCpu = 2,
+ }

+ public class Windows.Media.Effects.ProcessAudioFrameContext {
+ 	public AudioFrame InputFrame { get; }
+ 	public AudioFrame OutputFrame { get; }
+ }

+ public class Windows.Media.Effects.ProcessVideoFrameContext {
+ 	public VideoFrame InputFrame { get; }
+ 	public VideoFrame OutputFrame { get; }
+ }

+ public class Windows.Media.Effects.VideoCompositorDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ 	public VideoCompositorDefinition( string activatableClassId );
+ 	public VideoCompositorDefinition( string activatableClassId, IPropertySet props );
+ }

+ public class Windows.Media.Effects.VideoEffectDefinition {
+ 	public string ActivatableClassId { get; }
+ 	public IPropertySet Properties { get; }
+ 	public VideoEffectDefinition( string activatableClassId );
+ 	public VideoEffectDefinition( string activatableClassId, IPropertySet props );
+ }

+ public interface Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint {
+ 	public bool IsEnabled { get; set; }
+ 	public SpeechRecognitionConstraintProbability Probability { get; set; }
+ 	public string Tag { get; set; }
+ 	public SpeechRecognitionConstraintType Type { get; }
+ }

+ public enum Windows.Media.SpeechRecognition.SpeechRecognitionAudioProblem {
+ 	None = 0,
+ 	TooNoisy = 1,
+ 	NoSignal = 2,
+ 	TooLoud = 3,
+ 	TooQuiet = 4,
+ 	TooFast = 5,
+ 	TooSlow = 6,
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionCompilationResult {
+ 	public SpeechRecognitionResultStatus Status { get; }
+ }

+ public enum Windows.Media.SpeechRecognition.SpeechRecognitionConfidence {
+ 	High = 0,
+ 	Medium = 1,
+ 	Low = 2,
+ 	Rejected = 3,
+ }

+ public enum Windows.Media.SpeechRecognition.SpeechRecognitionConstraintProbability {
+ 	Default = 0,
+ 	Min = 1,
+ 	Max = 2,
+ }

+ public enum Windows.Media.SpeechRecognition.SpeechRecognitionConstraintType {
+ 	Topic = 0,
+ 	List = 1,
+ 	Grammar = 2,
+ 	VoiceCommandDefinition = 3,
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionGrammarFileConstraint {
+ 	public StorageFile GrammarFile { get; }
+ 	public string Tag { get; set; }
+ 	public SpeechRecognitionConstraintProbability Probability { get; set; }
+ 	public bool IsEnabled { get; set; }
+ 	public SpeechRecognitionConstraintType Type { get; }
+ 	public SpeechRecognitionGrammarFileConstraint( StorageFile file );
+ 	public SpeechRecognitionGrammarFileConstraint( StorageFile file, string tag );
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionListConstraint {
+ 	public IVector<string> Commands { get; }
+ 	public string Tag { get; set; }
+ 	public SpeechRecognitionConstraintProbability Probability { get; set; }
+ 	public bool IsEnabled { get; set; }
+ 	public SpeechRecognitionConstraintType Type { get; }
+ 	public SpeechRecognitionListConstraint( IIterable<string> commands );
+ 	public SpeechRecognitionListConstraint( IIterable<string> commands, string tag );
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs {
+ 	public SpeechRecognitionAudioProblem Problem { get; }
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionResult {
+ 	public SpeechRecognitionConfidence Confidence { get; }
+ 	public ISpeechRecognitionConstraint Constraint { get; }
+ 	public double RawConfidence { get; }
+ 	public IVectorView<string> RulePath { get; }
+ 	public SpeechRecognitionSemanticInterpretation SemanticInterpretation { get; }
+ 	public SpeechRecognitionResultStatus Status { get; }
+ 	public string Text { get; }
+ 	public IVectorView<SpeechRecognitionResult> GetAlternates( uint alternates );
+ }

+ public enum Windows.Media.SpeechRecognition.SpeechRecognitionResultStatus {
+ 	Success = 0,
+ 	TopicLanguageNotSupported = 1,
+ 	GrammarLanguageMismatch = 2,
+ 	GrammarCompilationFailure = 3,
+ 	AudioQualityFailure = 4,
+ 	UserCanceled = 5,
+ 	Unknown = 6,
+ }

+ public enum Windows.Media.SpeechRecognition.SpeechRecognitionScenario {
+ 	WebSearch = 0,
+ 	Dictation = 1,
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionSemanticInterpretation {
+ 	public IMapView<string, IVectorView<string>> Properties { get; }
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionTopicConstraint {
+ 	public SpeechRecognitionScenario Scenario { get; }
+ 	public string TopicHint { get; }
+ 	public string Tag { get; set; }
+ 	public SpeechRecognitionConstraintProbability Probability { get; set; }
+ 	public bool IsEnabled { get; set; }
+ 	public SpeechRecognitionConstraintType Type { get; }
+ 	public SpeechRecognitionTopicConstraint( SpeechRecognitionScenario scenario, string topicHint );
+ 	public SpeechRecognitionTopicConstraint( SpeechRecognitionScenario scenario, string topicHint, string tag );
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognitionVoiceCommandDefinitionConstraint {
+ 	public string Tag { get; set; }
+ 	public SpeechRecognitionConstraintProbability Probability { get; set; }
+ 	public bool IsEnabled { get; set; }
+ 	public SpeechRecognitionConstraintType Type { get; }
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognizer {
+ 	public IVector<ISpeechRecognitionConstraint> Constraints { get; }
+ 	public Language CurrentLanguage { get; }
+ 	public SpeechRecognizerTimeouts Timeouts { get; }
+ 	public SpeechRecognizerUIOptions UIOptions { get; }
+ 	public IVectorView<Language> SupportedGrammarLanguages { get; }
+ 	public IVectorView<Language> SupportedTopicLanguages { get; }
+ 	public Language SystemSpeechLanguage { get; }
+ 	public SpeechRecognizer( Language language );
+ 	public SpeechRecognizer();
+ 	public IAsyncOperation<SpeechRecognitionCompilationResult> CompileConstraintsAsync();
+ 	public IAsyncOperation<SpeechRecognitionResult> RecognizeAsync();
+ 	public IAsyncOperation<SpeechRecognitionResult> RecognizeWithUIAsync();
+ 	public void Close();
+ 	TypedEventHandler<SpeechRecognizer, SpeechRecognitionQualityDegradingEventArgs> RecognitionQualityDegrading;
+ 	TypedEventHandler<SpeechRecognizer, SpeechRecognizerStateChangedEventArgs> StateChanged;
+ }

+ public enum Windows.Media.SpeechRecognition.SpeechRecognizerState {
+ 	Idle = 0,
+ 	Capturing = 1,
+ 	Processing = 2,
+ 	SoundStarted = 3,
+ 	SoundEnded = 4,
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs {
+ 	public SpeechRecognizerState State { get; }
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognizerTimeouts {
+ 	public TimeSpan InitialSilenceTimeout { get; set; }
+ 	public TimeSpan EndSilenceTimeout { get; set; }
+ 	public TimeSpan BabbleTimeout { get; set; }
+ }

+ public class Windows.Media.SpeechRecognition.SpeechRecognizerUIOptions {
+ 	public bool ShowConfirmation { get; set; }
+ 	public bool IsReadBackEnabled { get; set; }
+ 	public string ExampleText { get; set; }
+ 	public string AudiblePrompt { get; set; }
+ }

+ public class Windows.Media.Streaming.Adaptive.AdaptiveMediaSource {
+ 	public TimeSpan PreferredLiveOffset { get; set; }
+ 	public IReference<uint> MinBitrateAllowed { get; set; }
+ 	public IReference<uint> MaxBitrateAllowed { get; set; }
+ 	public uint InitialBitrate { get; set; }
+ 	public IVectorView<uint> AvailableBitrates { get; }
+ 	public uint CurrentBitrate { get; }
+ 	public bool IsLive { get; }
+ 	public static bool IsContentTypeSupported( string result );
+ 	public static IAsyncOperation<AdaptiveMediaSourceCreationResult> CreateAsync( Uri result );
+ 	public static IAsyncOperation<AdaptiveMediaSourceCreationResult> CreateAsync( Uri result, string uri, IInputStream contentType );
+ 	TypedEventHandler<AdaptiveMediaSource, AdaptiveMediaSourceCurrentBitrateChangedEventArgs> CurrentBitrateChanged;
+ }

+ public class Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult {
+ 	public AdaptiveMediaSource MediaSource { get; }
+ 	public AdaptiveMediaSourceCreationStatus Status { get; }
+ }

+ public enum Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationStatus {
+ 	Success = 0,
+ 	ManifestDownloadFailure = 1,
+ 	ManifestParseFailure = 2,
+ 	UnsupportedManifestContentType = 3,
+ 	UnsupportedManifestVersion = 4,
+ 	UnsupportedManifestProfile = 5,
+ 	UnknownFailure = 6,
+ }

+ public class Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCurrentBitrateChangedEventArgs {
+ 	public uint NewValue { get; }
+ 	public uint OldValue { get; }
+ }


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

 new file: Windows 10/Windows.Networking.winmd
 old file: Windows 8.1 Update/Windows.Networking.winmd

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

| public class Windows.Networking.BackgroundTransfer.BackgroundDownloader {
+ 	public BackgroundTransferCompletionGroup CompletionGroup { get; }
+ 	public BackgroundDownloader( BackgroundTransferCompletionGroup completionGroup );
| }

+ public class Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup {
+ 	public bool IsEnabled { get; }
+ 	public IBackgroundTrigger Trigger { get; }
+ 	public BackgroundTransferCompletionGroup();
+ 	public void Enable();
+ }

+ public class Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroupTriggerDetails {
+ 	public IVectorView<DownloadOperation> Downloads { get; }
+ 	public IVectorView<UploadOperation> Uploads { get; }
+ }

| public class Windows.Networking.BackgroundTransfer.BackgroundUploader {
+ 	public BackgroundTransferCompletionGroup CompletionGroup { get; }
+ 	public BackgroundUploader( BackgroundTransferCompletionGroup completionGroup );
| }

| public class Windows.Networking.NetworkOperators.MobileBroadbandDeviceInformation {
+ 	public MobileBroadbandPinManager PinManager { get; }
+ 	public string Revision { get; }
+ 	public string SerialNumber { get; }
| }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandDeviceService {
+ 	public Guid DeviceServiceId { get; }
+ 	public IVectorView<uint> SupportedCommands { get; }
+ 	public MobileBroadbandDeviceServiceDataSession OpenDataSession();
+ 	public MobileBroadbandDeviceServiceCommandSession OpenCommandSession();
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandResult {
+ 	public IBuffer ResponseData { get; }
+ 	public uint StatusCode { get; }
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandSession {
+ 	public IAsyncOperation<MobileBroadbandDeviceServiceCommandResult> SendQueryCommandAsync( uint asyncInfo, IBuffer commandId );
+ 	public IAsyncOperation<MobileBroadbandDeviceServiceCommandResult> SendSetCommandAsync( uint asyncInfo, IBuffer commandId );
+ 	public void CloseSession();
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs {
+ 	public IBuffer ReceivedData { get; }
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession {
+ 	public IAsyncAction WriteDataAsync( IBuffer asyncInfo );
+ 	public void CloseSession();
+ 	TypedEventHandler<MobileBroadbandDeviceServiceDataSession, MobileBroadbandDeviceServiceDataReceivedEventArgs> DataReceived;
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceInformation {
+ 	public Guid DeviceServiceId { get; }
+ 	public bool IsDataReadSupported { get; }
+ 	public bool IsDataWriteSupported { get; }
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandModem {
+ 	public MobileBroadbandAccount CurrentAccount { get; }
+ 	public MobileBroadbandDeviceInformation DeviceInformation { get; }
+ 	public IVectorView<MobileBroadbandDeviceServiceInformation> DeviceServices { get; }
+ 	public uint MaxDeviceServiceCommandSizeInBytes { get; }
+ 	public uint MaxDeviceServiceDataSizeInBytes { get; }
+ 	public MobileBroadbandUicc Uicc { get; }
+ 	public MobileBroadbandDeviceService GetDeviceService( Guid value );
+ 	public static string GetDeviceSelector();
+ 	public static MobileBroadbandModem FromId( string value );
+ 	public static MobileBroadbandModem GetDefault();
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandPin {
+ 	public uint AttemptsRemaining { get; }
+ 	public bool Enabled { get; }
+ 	public MobileBroadbandPinFormat Format { get; }
+ 	public MobileBroadbandPinLockState LockState { get; }
+ 	public uint MaxLength { get; }
+ 	public uint MinLength { get; }
+ 	public MobileBroadbandPinType Type { get; }
+ 	public IAsyncOperation<MobileBroadbandPinOperationResult> EnableAsync( string asyncInfo );
+ 	public IAsyncOperation<MobileBroadbandPinOperationResult> DisableAsync( string asyncInfo );
+ 	public IAsyncOperation<MobileBroadbandPinOperationResult> EnterAsync( string asyncInfo );
+ 	public IAsyncOperation<MobileBroadbandPinOperationResult> ChangeAsync( string asyncInfo, string currentPin );
+ 	public IAsyncOperation<MobileBroadbandPinOperationResult> UnblockAsync( string asyncInfo, string pinUnblockKey );
+ }

+ public enum Windows.Networking.NetworkOperators.MobileBroadbandPinFormat {
+ 	Unknown = 0,
+ 	Numeric = 1,
+ 	Alphanumeric = 2,
+ }

+ public enum Windows.Networking.NetworkOperators.MobileBroadbandPinLockState {
+ 	Unknown = 0,
+ 	Unlocked = 1,
+ 	PinRequired = 2,
+ 	PinUnblockKeyRequired = 3,
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandPinManager {
+ 	public IVectorView<MobileBroadbandPinType> SupportedPins { get; }
+ 	public MobileBroadbandPin GetPin( MobileBroadbandPinType value );
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult {
+ 	public uint AttemptsRemaining { get; }
+ 	public bool Succeeded { get; }
+ }

+ public enum Windows.Networking.NetworkOperators.MobileBroadbandPinType {
+ 	None = 0,
+ 	Custom = 1,
+ 	Pin1 = 2,
+ 	Pin2 = 3,
+ 	SimPin = 4,
+ 	FirstSimPin = 5,
+ 	NetworkPin = 6,
+ 	NetworkSubsetPin = 7,
+ 	ServiceProviderPin = 8,
+ 	CorporatePin = 9,
+ 	SubsidyLock = 10,
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandUicc {
+ 	public string SimIccId { get; }
+ 	public IVectorView<string> UiccAppIds { get; }
+ }

| public enum Windows.Networking.PushNotifications.PushNotificationType {
+ 	TileFlyout = 4,
| }

+ public class Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult {
+ 	public bool HasInstanceNameChanged { get; }
+ 	public HostName IPAddress { get; }
+ 	public DnssdRegistrationStatus Status { get; }
+ 	public DnssdRegistrationResult();
+ 	public string ToString();
+ }

+ public enum Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationStatus {
+ 	Success = 0,
+ 	InvalidServiceName = 1,
+ 	ServerError = 2,
+ 	SecurityError = 3,
+ }

+ public class Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance {
+ 	public ushort Weight { get; set; }
+ 	public ushort Priority { get; set; }
+ 	public ushort Port { get; set; }
+ 	public HostName HostName { get; set; }
+ 	public HostName DnssdServiceInstanceName { get; set; }
+ 	public IMap<string, string> TextAttributes { get; }
+ 	public DnssdServiceInstance( HostName DnssdServiceInstanceName, HostName hostName, ushort port );
+ 	public IAsyncOperation<DnssdRegistrationResult> RegisterStreamSocketListenerAsync( StreamSocketListener result );
+ 	public IAsyncOperation<DnssdRegistrationResult> RegisterStreamSocketListenerAsync( StreamSocketListener result, NetworkAdapter socket );
+ 	public IAsyncOperation<DnssdRegistrationResult> RegisterDatagramSocketAsync( DatagramSocket result );
+ 	public IAsyncOperation<DnssdRegistrationResult> RegisterDatagramSocketAsync( DatagramSocket result, NetworkAdapter socket );
+ 	public string ToString();
+ }

+ public class Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstanceCollection {
+ 	public uint Size { get; }
+ 	public DnssdServiceInstance GetAt( uint returnValue );
+ 	public bool IndexOf( DnssdServiceInstance returnValue, ref uint value );
+ 	public uint GetMany( uint returnValue, DnssdServiceInstance[] startIndex );
+ 	public IIterator<DnssdServiceInstance> First();
+ }

+ public class Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher {
+ 	public DnssdServiceWatcherStatus Status { get; }
+ 	public void Start();
+ 	public void Stop();
+ 	TypedEventHandler<DnssdServiceWatcher, DnssdServiceInstance> Added;
+ 	TypedEventHandler<DnssdServiceWatcher, object> EnumerationCompleted;
+ 	TypedEventHandler<DnssdServiceWatcher, object> Stopped;
+ }

+ public enum Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcherStatus {
+ 	Created = 0,
+ 	Started = 1,
+ 	EnumerationCompleted = 2,
+ 	Stopping = 3,
+ 	Stopped = 4,
+ 	Aborted = 5,
+ }

| public class Windows.Networking.Sockets.DatagramSocket {
+ 	public void TransferOwnership( Guid taskId, string socketId );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data, SocketActivityConnectedStandbyAction connectedStandbyAction );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data, SocketActivityConnectedStandbyAction connectedStandbyAction, TimeSpan keepAliveTime );
| }

+ public enum Windows.Networking.Sockets.SocketActivityConnectedStandbyAction {
+ 	DoNotWake = 0,
+ 	Wake = 1,
+ }

+ public class Windows.Networking.Sockets.SocketActivityContext {
+ 	public IBuffer Data { get; }
+ 	public SocketActivityContext();
+ }

+ public class Windows.Networking.Sockets.SocketActivityInformation {
+ 	public SocketActivityContext Context { get; }
+ 	public DatagramSocket DatagramSocket { get; }
+ 	public string Id { get; }
+ 	public SocketActivityType SocketType { get; }
+ 	public StreamSocket StreamSocket { get; }
+ 	public StreamSocketListener StreamSocketListener { get; }
+ 	public Guid TaskId { get; }
+ 	public IMapView<string, SocketActivityInformation> AllSockets { get; }
+ }

+ public class Windows.Networking.Sockets.SocketActivityTriggerDetails {
+ 	public SocketActivityTriggerReason Reason { get; }
+ 	public SocketActivityInformation SocketInformation { get; }
+ }

+ public enum Windows.Networking.Sockets.SocketActivityTriggerReason {
+ 	None = 0,
+ 	SocketActivity = 1,
+ 	ConnectionAccepted = 2,
+ 	KeepAliveTimerExpired = 3,
+ 	SocketClosed = 4,
+ }

+ public enum Windows.Networking.Sockets.SocketActivityType {
+ 	None = 0,
+ 	StreamSocketListener = 1,
+ 	DatagramSocket = 2,
+ 	StreamSocket = 3,
+ }

| public class Windows.Networking.Sockets.StreamSocket {
+ 	public void TransferOwnership( Guid taskId, string socketId );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data, SocketActivityConnectedStandbyAction connectedStandbyAction );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data, SocketActivityConnectedStandbyAction connectedStandbyAction, TimeSpan keepAliveTime );
| }

| public class Windows.Networking.Sockets.StreamSocketListener {
+ 	public void TransferOwnership( Guid taskId, string socketId );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data );
+ 	public void TransferOwnership( Guid taskId, string socketId, SocketActivityContext data, SocketActivityConnectedStandbyAction connectedStandbyAction );
| }

| public class Windows.Networking.Sockets.StreamSocketListenerControl {
+ 	public byte OutboundUnicastHopLimit { get; set; }
+ 	public uint OutboundBufferSizeInBytes { get; set; }
+ 	public bool NoDelay { get; set; }
+ 	public bool KeepAlive { get; set; }
| }

| public class Windows.Networking.Vpn.VpnChannelConfiguration {
+ 	public IVectorView<Uri> ServerUris { get; }
| }


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

 new file: Windows 10/Windows.Security.winmd
 old file: Windows 8.1 Update/Windows.Security.winmd

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

+ public class Windows.Security.Authentication.Web.Core.WebAccountChangedEventArgs {
+ 	public WebAccount WebAccount { get; }
+ }

+ public class Windows.Security.Authentication.Web.Core.WebAccountDeletedEventArgs {
+ 	public WebAccount WebAccount { get; }
+ }

+ public class Windows.Security.Authentication.Web.Core.WebAuthenticationCoreManager {
+ 	public static IAsyncOperation<WebTokenRequestResult> GetTokenSilentlyAsync( WebTokenRequest asyncInfo );
+ 	public static IAsyncOperation<WebTokenRequestResult> GetTokenSilentlyAsync( WebTokenRequest asyncInfo, WebAccount request );
+ 	public static IAsyncOperation<WebTokenRequestResult> GetTokenSilentlyWithHintsAsync( WebTokenRequest asyncInfo, IVectorView<WebAccount> request );
+ 	public static void RequestTokenAndContinue( WebTokenRequest request );
+ 	public static void RequestTokenAndContinue( WebTokenRequest request, PropertySet continuationData );
+ 	public static void RequestTokenAndContinue( WebTokenRequest request, PropertySet continuationData, WebAccount webAccount );
+ 	public static void RequestTokenWithHintsAndContinue( WebTokenRequest request, PropertySet continuationData, IVectorView<WebAccount> webAccounts );
+ 	public static IAsyncOperation<WebAccount> FindAccountAsync( string asyncInfo, string webAccountProviderId );
+ 	public static IAsyncOperation<IVectorView<WebAccount>> FindAllAccountsAsync();
+ 	public static IAsyncAction ForgetAccountAsync( WebAccount asyncInfo );
+ 	TypedEventHandler<WebAccount, WebAccountChangedEventArgs> AccountChanged;
+ 	TypedEventHandler<WebAccount, WebAccountDeletedEventArgs> AccountDeleted;
+ }

+ public class Windows.Security.Authentication.Web.Core.WebTokenRequest {
+ 	public string ClientId { get; }
+ 	public WebTokenRequestPromptType PromptType { get; }
+ 	public IMap<string, string> Properties { get; }
+ 	public string Scope { get; }
+ 	public string WebAccountProviderId { get; }
+ 	public WebTokenRequest( string webAccountProviderId, string scope, string clientId );
+ 	public WebTokenRequest( string webAccountProviderId, string scope, string clientId, WebTokenRequestPromptType promptType );
+ }

+ public enum Windows.Security.Authentication.Web.Core.WebTokenRequestPromptType {
+ 	Default = 0,
+ 	ForceAuthentication = 1,
+ }

+ public class Windows.Security.Authentication.Web.Core.WebTokenRequestResult {
+ 	public IVectorView<WebTokenResponse> ResponseData { get; }
+ 	public WebTokenRequestStatus ResponseStatus { get; }
+ }

+ public enum Windows.Security.Authentication.Web.Core.WebTokenRequestStatus {
+ 	Success = 0,
+ 	UserCancel = 1,
+ 	AccountSwitch = 2,
+ 	UserInteractionRequired = 3,
+ 	AccountProviderNotAvailable = 4,
+ }

+ public class Windows.Security.Authentication.Web.Core.WebTokenResponse {
+ 	public IMap<string, string> Properties { get; }
+ 	public string Token { get; }
+ 	public WebAccount WebAccount { get; }
+ 	public WebTokenResponse( string token, WebAccount webAccount );
+ }

+ public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenObjects {
+ 	public WebProviderTokenRequest Request { get; }
+ 	public IVector<WebProviderTokenResponse> Responses { get; }
+ 	public void ReportCompleted();
+ 	public void ReportCancelled();
+ 	public void ReportUserInteractionRequired();
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountManager {
+ 	public static IAsyncAction UpdateWebAccountPropertiesAsync( WebAccount asyncInfo, string webAccount, IMapView<string, string> webAccountUserName );
+ 	public static IAsyncOperation<WebAccount> AddWebAccountAsync( string asyncInfo, string webAccountId, IMapView<string, string> webAccountUserName );
+ 	public static IAsyncAction DeleteWebAccountAsync( WebAccount asyncInfo );
+ 	public static IAsyncOperation<IVectorView<WebAccount>> FindAllProviderWebAccountsAsync();
+ 	public static void SendTokenResultCompleted( WebAccountProviderOperation pickerOperation );
+ 	public static void SendTokenResultCancelled( WebAccountProviderOperation pickerOperation );
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderOperation {
+ 	public WebAccountProviderOption Option { get; }
+ 	public IVectorView<WebAccount> WebAccounts { get; }
+ 	public WebProviderTokenRequest Request { get; }
+ 	public IVector<WebProviderTokenResponse> Responses { get; }
+ 	public void ReportCompleted();
+ 	public void ReportCancelled();
+ 	public void ReportUserInteractionRequired();
+ }

+ public enum Windows.Security.Authentication.Web.Provider.WebAccountProviderOption {
+ 	RequestToken = 0,
+ 	AddAccount = 1,
+ 	ManageAccount = 2,
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderTriggerDetails {
+ 	public WebProviderTokenRequest Request { get; }
+ 	public IVector<WebProviderTokenResponse> Responses { get; }
+ 	public void ReportCompleted();
+ 	public void ReportCancelled();
+ 	public void ReportUserInteractionRequired();
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebProviderTokenRequest {
+ 	public Uri ApplicationCallbackUri { get; }
+ 	public WebTokenRequest Request { get; }
+ 	public IVectorView<WebAccount> WebAccounts { get; }
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse {
+ 	public DateTime CacheExpirationTime { get; }
+ 	public WebTokenResponse Response { get; }
+ 	public WebProviderTokenResponse( WebTokenResponse webTokenResponse, DateTime expirationTime );
+ }

* public interface Windows.Security.Credentials.IWebAccount;

| public class Windows.Security.Credentials.WebAccount {
+ 	public string Id { get; }
+ 	public IMapView<string, string> Properties { get; }
| }

| public class Windows.Security.Credentials.WebAccountProvider {
+ 	public string DisplayPurpose { get; }
+ 	public IRandomAccessStreamReference Icon { get; }
| }

| public class Windows.Security.Cryptography.Core.AsymmetricAlgorithmNames {
+ 	public string EcdsaSha512 { get; }
+ 	public string EcdsaSha256 { get; }
+ 	public string EcdsaSha384 { get; }
| }

| public class Windows.Security.Cryptography.Core.AsymmetricKeyAlgorithmProvider {
+ 	public CryptographicKey CreateKeyPairWithCurveName( string key );
+ 	public CryptographicKey CreateKeyPairWithCurveParameters( byte[] key );
| }

| public enum Windows.Security.Cryptography.Core.CryptographicPrivateKeyBlobType {
+ 	BCryptEccFullPrivateKey = 4,
| }

| public enum Windows.Security.Cryptography.Core.CryptographicPublicKeyBlobType {
+ 	BCryptEccFullPublicKey = 4,
| }

+ public class Windows.Security.Cryptography.Core.EccCurveNames {
+ 	public IVectorView<string> AllEccCurveNames { get; }
+ 	public string NistP256 { get; }
+ 	public string NistP384 { get; }
+ 	public string NistP521 { get; }
+ 	public string Secp256k1 { get; }
+ 	public string Secp256r1 { get; }
+ 	public string Secp384r1 { get; }
+ 	public string Secp521r1 { get; }
+ 	public string X962P192v1 { get; }
+ 	public string X962P192v2 { get; }
+ 	public string X962P192v3 { get; }
+ 	public string X962P192v4 { get; }
+ 	public string X962P239v1 { get; }
+ 	public string X962P239v2 { get; }
+ 	public string X962P239v3 { get; }
+ 	public string X962P256v1 { get; }
+ }


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

 new file: Windows 10/Windows.Services.winmd
 old file: Windows 8.1 Update/Windows.Services.winmd (NOT EXISTS!)

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

+ public class Windows.Services.Maps.MapAddress {
+ 	public string BuildingFloor { get; }
+ 	public string BuildingName { get; }
+ 	public string BuildingRoom { get; }
+ 	public string BuildingWing { get; }
+ 	public string Continent { get; }
+ 	public string Country { get; }
+ 	public string CountryCode { get; }
+ 	public string District { get; }
+ 	public string Neighborhood { get; }
+ 	public string PostCode { get; }
+ 	public string Region { get; }
+ 	public string RegionCode { get; }
+ 	public string Street { get; }
+ 	public string StreetNumber { get; }
+ 	public string Town { get; }
+ }

+ public class Windows.Services.Maps.MapLocation {
+ 	public MapAddress Address { get; }
+ 	public string Description { get; }
+ 	public string DisplayName { get; }
+ 	public Geopoint Point { get; }
+ }

+ public class Windows.Services.Maps.MapLocationFinder {
+ 	public static IAsyncOperation<MapLocationFinderResult> FindLocationsAtAsync( Geopoint result );
+ 	public static IAsyncOperation<MapLocationFinderResult> FindLocationsAsync( string result, Geopoint searchText );
+ 	public static IAsyncOperation<MapLocationFinderResult> FindLocationsAsync( string result, Geopoint searchText, uint referencePoint );
+ }

+ public class Windows.Services.Maps.MapLocationFinderResult {
+ 	public IVectorView<MapLocation> Locations { get; }
+ 	public MapLocationFinderStatus Status { get; }
+ }

+ public enum Windows.Services.Maps.MapLocationFinderStatus {
+ 	Success = 0,
+ 	UnknownError = 1,
+ 	InvalidCredentials = 2,
+ 	BadLocation = 3,
+ 	IndexFailure = 4,
+ 	NetworkFailure = 5,
+ }

+ public class Windows.Services.Maps.MapManager {
+ 	public static void ShowDownloadedMapsUI();
+ 	public static void ShowMapsUpdateUI();
+ }

+ public enum Windows.Services.Maps.MapManeuverNotices {
+ 	None = 0,
+ 	Toll = 1,
+ 	Unpaved = 2,
+ }

+ public class Windows.Services.Maps.MapRoute {
+ 	public GeoboundingBox BoundingBox { get; }
+ 	public TimeSpan EstimatedDuration { get; }
+ 	public bool IsTrafficBased { get; }
+ 	public IVectorView<MapRouteLeg> Legs { get; }
+ 	public double LengthInMeters { get; }
+ 	public Geopath Path { get; }
+ }

+ public class Windows.Services.Maps.MapRouteFinder {
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteAsync( Geopoint result, Geopoint startPoint );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteAsync( Geopoint result, Geopoint startPoint, MapRouteOptimization endPoint );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteAsync( Geopoint result, Geopoint startPoint, MapRouteOptimization endPoint, MapRouteRestrictions optimization );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteAsync( Geopoint result, Geopoint startPoint, MapRouteOptimization endPoint, MapRouteRestrictions optimization, double restrictions );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromWaypointsAsync( IIterable<Geopoint> result );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromWaypointsAsync( IIterable<Geopoint> result, MapRouteOptimization wayPoints );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromWaypointsAsync( IIterable<Geopoint> result, MapRouteOptimization wayPoints, MapRouteRestrictions optimization );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromWaypointsAsync( IIterable<Geopoint> result, MapRouteOptimization wayPoints, MapRouteRestrictions optimization, double restrictions );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetWalkingRouteAsync( Geopoint result, Geopoint startPoint );
+ 	public static IAsyncOperation<MapRouteFinderResult> GetWalkingRouteFromWaypointsAsync( IIterable<Geopoint> result );
+ }

+ public class Windows.Services.Maps.MapRouteFinderResult {
+ 	public MapRoute Route { get; }
+ 	public MapRouteFinderStatus Status { get; }
+ }

+ public enum Windows.Services.Maps.MapRouteFinderStatus {
+ 	Success = 0,
+ 	UnknownError = 1,
+ 	InvalidCredentials = 2,
+ 	NoRouteFound = 3,
+ 	NoRouteFoundWithGivenOptions = 4,
+ 	StartPointNotFound = 5,
+ 	EndPointNotFound = 6,
+ 	NoPedestrianRouteFound = 7,
+ 	NetworkFailure = 8,
+ }

+ public class Windows.Services.Maps.MapRouteLeg {
+ 	public GeoboundingBox BoundingBox { get; }
+ 	public TimeSpan EstimatedDuration { get; }
+ 	public double LengthInMeters { get; }
+ 	public IVectorView<MapRouteManeuver> Maneuvers { get; }
+ 	public Geopath Path { get; }
+ }

+ public class Windows.Services.Maps.MapRouteManeuver {
+ 	public string ExitNumber { get; }
+ 	public string InstructionText { get; }
+ 	public MapRouteManeuverKind Kind { get; }
+ 	public double LengthInMeters { get; }
+ 	public MapManeuverNotices ManeuverNotices { get; }
+ 	public Geopoint StartingPoint { get; }
+ }

+ public enum Windows.Services.Maps.MapRouteManeuverKind {
+ 	None = 0,
+ 	Start = 1,
+ 	Stopover = 2,
+ 	StopoverResume = 3,
+ 	End = 4,
+ 	GoStraight = 5,
+ 	UTurnLeft = 6,
+ 	UTurnRight = 7,
+ 	TurnKeepLeft = 8,
+ 	TurnKeepRight = 9,
+ 	TurnLightLeft = 10,
+ 	TurnLightRight = 11,
+ 	TurnLeft = 12,
+ 	TurnRight = 13,
+ 	TurnHardLeft = 14,
+ 	TurnHardRight = 15,
+ 	FreewayEnterLeft = 16,
+ 	FreewayEnterRight = 17,
+ 	FreewayLeaveLeft = 18,
+ 	FreewayLeaveRight = 19,
+ 	FreewayContinueLeft = 20,
+ 	FreewayContinueRight = 21,
+ 	TrafficCircleLeft = 22,
+ 	TrafficCircleRight = 23,
+ 	TakeFerry = 24,
+ }

+ public enum Windows.Services.Maps.MapRouteOptimization {
+ 	Time = 0,
+ 	Distance = 1,
+ 	TimeWithTraffic = 2,
+ }

+ public enum Windows.Services.Maps.MapRouteRestrictions {
+ 	None = 0,
+ 	Highways = 1,
+ 	TollRoads = 2,
+ 	Ferries = 4,
+ 	Tunnels = 8,
+ 	DirtRoads = 16,
+ }

+ public class Windows.Services.Maps.MapService {
+ 	public string ServiceToken { get; set; }
+ }


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

 new file: Windows 10/Windows.Storage.winmd
 old file: Windows 8.1 Update/Windows.Storage.winmd

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

| public enum Windows.Storage.FileAccessMode {
+ 	ReadWriteNoDelete = 2,
| }

+ public interface Windows.Storage.Streams.IClosableBuffer {
+ 	public uint Capacity { get; }
+ 	public uint Length { get; set; }
+ }


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

 new file: Windows 10/Windows.System.winmd
 old file: Windows 8.1 Update/Windows.System.winmd

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

+ public enum Windows.System.BatteryStatus {
+ 	NotPresent = 0,
+ 	Discharging = 1,
+ 	Idle = 2,
+ 	Charging = 3,
+ }

+ public class Windows.System.PowerManager {
+ 	public BatteryStatus BatteryStatus { get; }
+ 	public PowerSavingStatus PowerSavingStatus { get; }
+ 	public PowerSupplyStatus PowerSupplyStatus { get; }
+ 	public int RemainingChargePercent { get; }
+ 	EventHandler<object> BatteryStatusChanged;
+ 	EventHandler<object> PowerSavingStatusChanged;
+ 	EventHandler<object> PowerSupplyStatusChanged;
+ 	EventHandler<object> RemainingChargePercentChanged;
+ }

+ public enum Windows.System.PowerSavingStatus {
+ 	Disabled = 0,
+ 	Off = 1,
+ 	On = 2,
+ }

+ public enum Windows.System.PowerSupplyStatus {
+ 	NotPresent = 0,
+ 	Inadequate = 1,
+ 	Adequate = 2,
+ }

+ public class Windows.System.Profile.KnownRetailInfoProperties {
+ 	public string BatteryLifeDescription { get; }
+ 	public string DisplayDescription { get; }
+ 	public string DisplayModelName { get; }
+ 	public string FormFactor { get; }
+ 	public string FrontCameraDescription { get; }
+ 	public string GraphicsDescription { get; }
+ 	public string HasNfc { get; }
+ 	public string HasOpticalDrive { get; }
+ 	public string HasSdSlot { get; }
+ 	public string IsFeatured { get; }
+ 	public string IsOfficeInstalled { get; }
+ 	public string ManufacturerName { get; }
+ 	public string Memory { get; }
+ 	public string ModelName { get; }
+ 	public string Price { get; }
+ 	public string ProcessorDescription { get; }
+ 	public string RearCameraDescription { get; }
+ 	public string RetailAccessCode { get; }
+ 	public string ScreenSize { get; }
+ 	public string StorageDescription { get; }
+ 	public string Weight { get; }
+ 	public string WindowsVersion { get; }
+ }

+ public class Windows.System.Profile.RetailInfo {
+ 	public bool IsDemoModeEnabled { get; }
+ 	public IMapView<string, object> Properties { get; }
+ }


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

 new file: Windows 10/Windows.UI.winmd
 old file: Windows 8.1 Update/Windows.UI.winmd

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

+ public class Windows.UI.Composition.ClipFadedRectangle : Windows.UI.Composition.ClipInstance {
+ 	public Inset Inset { get; set; }
+ }

+ public class Windows.UI.Composition.ClipInstance {
+ }

+ public class Windows.UI.Composition.CompositionDevice {
+ 	public CompositionDevice( Interop_DxgiDevice dxGraphics );
+ 	public ClipFadedRectangle CreateClipFadedRectangle();
+ 	public CompositionSurface TryCreateSurface( Size value, uint pixelSize, uint pixelFormat );
+ 	public CompositionTarget CreateTarget( Interop_Hwnd value );
+ 	public VisualCanvas CreateVisualCanvas();
+ 	public VisualImage CreateVisualImage();
+ 	public VisualInstance CreateVisualInstance();
+ 	public VisualSolidColor CreateVisualSolidColor();
+ 	public void BeginDeferCommit();
+ 	public void EndDeferCommit();
+ 	public void Close();
+ 	TypedEventHandler<CompositionDevice, uint> Committed;
+ }

+ public class Windows.UI.Composition.CompositionSurface {
+ 	public uint AlphaMode { get; }
+ 	public uint PixelFormat { get; }
+ 	public Size Size { get; }
+ 	public void BeginDraw( ref Interop_DxgiSurface dxSurface, ref Point offset );
+ 	public void EndDraw();
+ 	public void Close();
+ }

+ public class Windows.UI.Composition.CompositionTarget {
+ 	public VisualInstance Root { get; set; }
+ 	public void Close();
+ }

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

+ public interface Windows.UI.Composition.IVisualCollection {
+ 	public int Count { get; }
+ 	public void Add( VisualInstance newChild );
+ 	public void Add( VisualInstance newChild, bool above, VisualInstance reference );
+ 	public void Remove( VisualInstance child );
+ 	public void RemoveAll();
+ }

+ public interface Windows.UI.Composition.IVisualInstance {
+ 	public VisualCollection Children { get; }
+ 	public ClipInstance Clip { get; set; }
+ 	public Vector3 Offset { get; set; }
+ 	public VisualInstance Parent { get; }
+ 	public Size Size { get; set; }
+ }

+ public struct Windows.UI.Composition.Inset {
+ 	public float Left;
+ 	public float Top;
+ 	public float Right;
+ 	public float Bottom;
+ }

+ public struct Windows.UI.Composition.Interop_D2DDrawingContext {
+ 	public long Value;
+ }

+ public struct Windows.UI.Composition.Interop_DxgiDevice {
+ 	public long Value;
+ }

+ public struct Windows.UI.Composition.Interop_DxgiSurface {
+ 	public long Value;
+ }

+ public struct Windows.UI.Composition.Interop_Hwnd {
+ 	public long Value;
+ }

+ public class Windows.UI.Composition.VisualCanvas : Windows.UI.Composition.VisualInstance {
+ 	public Size Size { get; set; }
+ 	public Vector3 Offset { get; set; }
+ 	public ClipInstance Clip { get; set; }
+ 	public VisualCollection Children { get; }
+ 	public VisualInstance Parent { get; }
+ 	public Interop_D2DDrawingContext BeginDraw();
+ 	public void EndDraw();
+ 	public void Close();
+ }

+ public class Windows.UI.Composition.VisualCollection {
+ 	public int Count { get; }
+ 	public void Add( VisualInstance newChild );
+ 	public void Add( VisualInstance newChild, bool above, VisualInstance reference );
+ 	public void Remove( VisualInstance child );
+ 	public void RemoveAll();
+ 	public IIterator<VisualInstance> First();
+ }

+ public class Windows.UI.Composition.VisualImage : Windows.UI.Composition.VisualInstance {
+ 	public CompositionSurface Content { get; set; }
+ 	public Size Size { get; set; }
+ 	public Vector3 Offset { get; set; }
+ 	public ClipInstance Clip { get; set; }
+ 	public VisualCollection Children { get; }
+ 	public VisualInstance Parent { get; }
+ 	public void Close();
+ }

+ public class Windows.UI.Composition.VisualInstance {
+ 	public Size Size { get; set; }
+ 	public Vector3 Offset { get; set; }
+ 	public ClipInstance Clip { get; set; }
+ 	public VisualCollection Children { get; }
+ 	public VisualInstance Parent { get; }
+ 	public void Close();
+ }

+ public class Windows.UI.Composition.VisualSolidColor : Windows.UI.Composition.VisualInstance {
+ 	public Color Color { get; set; }
+ 	public Size Size { get; set; }
+ 	public Vector3 Offset { get; set; }
+ 	public ClipInstance Clip { get; set; }
+ 	public VisualCollection Children { get; }
+ 	public VisualInstance Parent { get; }
+ 	public void Close();
+ }

+ public class Windows.UI.Core.Text.CoreTextCompositionCompletedEventArgs {
+ 	public bool IsCanceled { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextCompositionStartedEventArgs {
+ 	public bool IsCanceled { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextEditContext {
+ 	public string Name { get; set; }
+ 	public bool IsReadOnly { get; set; }
+ 	public CoreTextInputScope InputScope { get; set; }
+ 	public void NotifyFocusEnter();
+ 	public void NotifyFocusLeave();
+ 	public void NotifyTextChanged( CoreTextRange modifiedRange, int newLength, CoreTextRange newSelection );
+ 	public void NotifySelectionChanged( CoreTextRange selection );
+ 	public void NotifyLayoutChanged();
+ 	TypedEventHandler<CoreTextEditContext, CoreTextCompositionCompletedEventArgs> CompositionCompleted;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextCompositionStartedEventArgs> CompositionStarted;
+ 	TypedEventHandler<CoreTextEditContext, object> FocusRemoved;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextFormatUpdatingEventArgs> FormatUpdating;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextLayoutRequestedEventArgs> LayoutRequested;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextSelectionRequestedEventArgs> SelectionRequested;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextSelectionUpdatingEventArgs> SelectionUpdating;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextTextRequestedEventArgs> TextRequested;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextTextUpdatingEventArgs> TextUpdating;
+ 	TypedEventHandler<CoreTextEditContext, CoreTextUnhandledKeyReceivedEventArgs> UnhandledKeyReceived;
+ }

+ public class Windows.UI.Core.Text.CoreTextFormatUpdatingEventArgs {
+ 	public CoreTextFormatUpdatingResult Result { get; set; }
+ 	public IReference<UIElementType> BackgroundColor { get; }
+ 	public bool IsCanceled { get; }
+ 	public CoreTextRange Range { get; }
+ 	public CoreTextFormatUpdatingReason Reason { get; }
+ 	public IReference<UIElementType> TextColor { get; }
+ 	public IReference<UIElementType> UnderlineColor { get; }
+ 	public IReference<UnderlineType> UnderlineType { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public enum Windows.UI.Core.Text.CoreTextFormatUpdatingReason {
+ 	None = 0,
+ 	CompositionUnconverted = 1,
+ 	CompositionConverted = 2,
+ 	CompositionTargetUnconverted = 3,
+ 	CompositionTargetConverted = 4,
+ }

+ public enum Windows.UI.Core.Text.CoreTextFormatUpdatingResult {
+ 	Succeeded = 0,
+ 	Failed = 1,
+ }

+ public enum Windows.UI.Core.Text.CoreTextInputScope {
+ 	Default = 0,
+ 	Url = 1,
+ 	FilePath = 2,
+ 	FileName = 3,
+ 	EmailUserName = 4,
+ 	EmailAddress = 5,
+ 	UserName = 6,
+ 	PersonalFullName = 7,
+ 	PersonalNamePrefix = 8,
+ 	PersonalGivenName = 9,
+ 	PersonalMiddleName = 10,
+ 	PersonalSurname = 11,
+ 	PersonalNameSuffix = 12,
+ 	Address = 13,
+ 	AddressPostalCode = 14,
+ 	AddressStreet = 15,
+ 	AddressStateOrProvince = 16,
+ 	AddressCity = 17,
+ 	AddressCountryName = 18,
+ 	AddressCountryShortName = 19,
+ 	CurrencyAmountAndSymbol = 20,
+ 	CurrencyAmount = 21,
+ 	Date = 22,
+ 	DateMonth = 23,
+ 	DateDay = 24,
+ 	DateYear = 25,
+ 	DateMonthName = 26,
+ 	DateDayName = 27,
+ 	Number = 29,
+ 	SingleCharacter = 30,
+ 	Password = 31,
+ 	TelephoneNumber = 32,
+ 	TelephoneCountryCode = 33,
+ 	TelephoneAreaCode = 34,
+ 	TelephoneLocalNumber = 35,
+ 	Time = 36,
+ 	TimeHour = 37,
+ 	TimeMinuteOrSecond = 38,
+ 	NumberFullWidth = 39,
+ 	AlphanumericHalfWidth = 40,
+ 	AlphanumericFullWidth = 41,
+ 	CurrencyChinese = 42,
+ 	Bopomofo = 43,
+ 	Hiragana = 44,
+ 	KatakanaHalfWidth = 45,
+ 	KatakanaFullWidth = 46,
+ 	Hanja = 47,
+ 	HangulHalfWidth = 48,
+ 	HangulFullWidth = 49,
+ 	Search = 50,
+ 	Formula = 51,
+ 	SearchIncremental = 52,
+ 	ChineseHalfWidth = 53,
+ 	ChineseFullWidth = 54,
+ 	NativeScript = 55,
+ 	Text = 57,
+ 	Chat = 58,
+ 	NameOrPhoneNumber = 59,
+ 	EmailUserNameOrAddress = 60,
+ 	Private = 61,
+ 	Maps = 62,
+ 	PasswordNumeric = 63,
+ 	FormulaNumber = 67,
+ }

+ public class Windows.UI.Core.Text.CoreTextLayoutBounds {
+ 	public Rect TextBounds { get; set; }
+ 	public Rect ControlBounds { get; set; }
+ }

+ public class Windows.UI.Core.Text.CoreTextLayoutRequestedEventArgs {
+ 	public bool IsCanceled { get; }
+ 	public CoreTextLayoutBounds LayoutBounds { get; }
+ 	public CoreTextRange Range { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public struct Windows.UI.Core.Text.CoreTextRange {
+ 	public int StartCaretPosition;
+ 	public int EndCaretPosition;
+ }

+ public class Windows.UI.Core.Text.CoreTextRequestDeferral {
+ 	public void Complete();
+ }

+ public class Windows.UI.Core.Text.CoreTextSelectionRequestedEventArgs {
+ 	public CoreTextRange Selection { get; set; }
+ 	public bool IsCanceled { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextSelectionUpdatingEventArgs {
+ 	public CoreTextSelectionUpdatingResult Result { get; set; }
+ 	public bool IsCanceled { get; }
+ 	public CoreTextRange Selection { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public enum Windows.UI.Core.Text.CoreTextSelectionUpdatingResult {
+ 	Succeeded = 0,
+ 	Failed = 1,
+ }

+ public class Windows.UI.Core.Text.CoreTextServicesConstants {
+ 	public char HiddenCharacter { get; }
+ }

+ public class Windows.UI.Core.Text.CoreTextServicesManager {
+ 	public CoreTextEditContext CreateEditContext();
+ 	public static CoreTextServicesManager GetForCurrentView();
+ }

+ public class Windows.UI.Core.Text.CoreTextTextRequestedEventArgs {
+ 	public string Text { get; set; }
+ 	public bool IsCanceled { get; }
+ 	public CoreTextRange Range { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextTextUpdatingEventArgs {
+ 	public CoreTextTextUpdatingResult Result { get; set; }
+ 	public bool IsCanceled { get; }
+ 	public CoreTextRange NewSelection { get; }
+ 	public CoreTextRange Range { get; }
+ 	public string Text { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

+ public enum Windows.UI.Core.Text.CoreTextTextUpdatingResult {
+ 	Succeeded = 0,
+ 	Failed = 1,
+ }

+ public class Windows.UI.Core.Text.CoreTextUnhandledKeyReceivedEventArgs {
+ 	public bool IsCanceled { get; }
+ 	public KeyEventArgs KeyEventArgs { get; }
+ 	public CoreTextRequestDeferral GetDeferral();
+ }

| public enum Windows.UI.Notifications.TileTemplateType {
+ 	TileSquare71x71IconWithBadge = 75,
+ 	TileSquare150x150IconWithBadge = 76,
+ 	TileWide310x150IconWithBadgeAndText = 77,
+ 	TileSquare71x71Image = 78,
+ 	TileTall150x310Image = 79,
- 	TileSquare99x99IconWithBadge = 1000,
- 	TileSquare210x210IconWithBadge = 1001,
- 	TileWide432x210IconWithBadgeAndText = 1002,
| }

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

+ public class Windows.UI.WebUI.WebUIWebAccountProviderContinuationEventArgs {
+ 	public ActivatedOperation ActivatedOperation { get; }
+ 	public WebTokenRequestResult Result { get; }
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ }


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

 new file: Windows 10/Windows.UI.Xaml.winmd
 old file: Windows 8.1 Update/Windows.UI.Xaml.winmd

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

| public class Windows.UI.Xaml.DependencyObject {
+ 	public long RegisterPropertyChangedCallback( DependencyProperty returnValue, DependencyPropertyChangedCallback dp );
+ 	public void UnregisterPropertyChangedCallback( DependencyProperty dp, long token );
| }

+ public void delegate Windows.UI.Xaml.DependencyPropertyChangedCallback( DependencyObject sender, DependencyProperty dp );

| public class Windows.UI.Xaml.DragEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ 	public DataPackageOperation AcceptedOperation { get; set; }
+ 	public DataPackageView DataView { get; }
+ 	public DragDropModifiers Modifiers { get; }
+ 	public CoreDragUI Visual { get; }
+ 	public DragOperationDeferral GetDeferral();
| }

+ public class Windows.UI.Xaml.DragOperationDeferral {
+ 	public void Complete();
+ }

+ public class Windows.UI.Xaml.KeyAccelerator : Windows.UI.Xaml.DependencyObject {
+ 	public VirtualKeyModifiers KeyModifiers { get; set; }
+ 	public VirtualKey Key { get; set; }
+ 	public DependencyProperty KeyModifiersProperty { get; }
+ 	public DependencyProperty KeyProperty { get; }
+ 	public KeyAccelerator();
+ 	TypedEventHandler<KeyAccelerator, object> KeyModifiersDown;
+ 	TypedEventHandler<KeyAccelerator, object> KeyModifiersUp;
+ 	TypedEventHandler<KeyAccelerator, object> Pressed;
+ }

| public class Windows.UI.Xaml.UIElement : Windows.UI.Xaml.DependencyObject {
| }

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

| public enum Windows.UI.Xaml.Automation.Peers.AutomationEvents {
+ 	InputReachedTarget = 22,
+ 	InputReachedOtherElement = 23,
+ 	InputDiscarded = 24,
+ 	WindowClosed = 25,
+ 	WindowOpened = 26,
| }

+ public enum Windows.UI.Xaml.Automation.Peers.AutomationNavigationDirection {
+ 	Parent = 0,
+ 	NextSibling = 1,
+ 	PreviousSibling = 2,
+ 	FirstChild = 3,
+ 	LastChild = 4,
+ }

| public class Windows.UI.Xaml.Automation.Peers.AutomationPeer : Windows.UI.Xaml.DependencyObject {
+ 	public object Navigate( AutomationNavigationDirection returnValue );
+ 	public object GetElementFromPoint( Point returnValue );
+ 	public object GetFocusedElement();
+ 	public void SetParent( AutomationPeer peer );
+ 	public static UiaRuntimeId GenerateUiaRuntimeId();
| }

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

| public class Windows.UI.Xaml.Automation.Peers.HubSectionAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+ 	public void ScrollIntoView();
| }

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

+ public class Windows.UI.Xaml.Automation.Peers.LoopingSelectorAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+ 	public ExpandCollapseState ExpandCollapseState { get; }
+ 	public bool CanSelectMultiple { get; }
+ 	public bool IsSelectionRequired { get; }
+ 	public double HorizontalScrollPercent { get; }
+ 	public double HorizontalViewSize { get; }
+ 	public bool HorizontallyScrollable { get; }
+ 	public double VerticalScrollPercent { get; }
+ 	public double VerticalViewSize { get; }
+ 	public bool VerticallyScrollable { get; }
+ 	public void Collapse();
+ 	public void Expand();
+ 	public IRawElementProviderSimple FindItemByProperty( IRawElementProviderSimple returnValue, AutomationProperty startAfter, object automationProperty );
+ 	public void Scroll( ScrollAmount horizontalAmount, ScrollAmount verticalAmount );
+ 	public void SetScrollPercent( double horizontalPercent, double verticalPercent );
+ 	public IRawElementProviderSimple[] GetSelection();
+ }

+ public class Windows.UI.Xaml.Automation.Peers.LoopingSelectorItemAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+ 	public bool IsSelected { get; }
+ 	public IRawElementProviderSimple SelectionContainer { get; }
+ 	public void ScrollIntoView();
+ 	public void AddToSelection();
+ 	public void RemoveFromSelection();
+ 	public void Select();
+ }

+ public class Windows.UI.Xaml.Automation.Peers.LoopingSelectorItemDataAutomationPeer : Windows.UI.Xaml.Automation.Peers.AutomationPeer {
+ 	public void Realize();
+ }

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

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

+ public class Windows.UI.Xaml.Automation.Peers.PivotAutomationPeer : Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer {
+ 	public bool CanSelectMultiple { get; }
+ 	public bool IsSelectionRequired { get; }
+ 	public double HorizontalScrollPercent { get; }
+ 	public double HorizontalViewSize { get; }
+ 	public bool HorizontallyScrollable { get; }
+ 	public double VerticalScrollPercent { get; }
+ 	public double VerticalViewSize { get; }
+ 	public bool VerticallyScrollable { get; }
+ 	public PivotAutomationPeer( Pivot owner );
+ 	public void Scroll( ScrollAmount horizontalAmount, ScrollAmount verticalAmount );
+ 	public void SetScrollPercent( double horizontalPercent, double verticalPercent );
+ 	public IRawElementProviderSimple[] GetSelection();
+ }

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

+ public class Windows.UI.Xaml.Automation.Peers.PivotItemDataAutomationPeer : Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer {
+ 	public bool IsSelected { get; }
+ 	public IRawElementProviderSimple SelectionContainer { get; }
+ 	public PivotItemDataAutomationPeer( object item, PivotAutomationPeer parent );
+ 	public void ScrollIntoView();
+ 	public void AddToSelection();
+ 	public void RemoveFromSelection();
+ 	public void Select();
+ 	public void Realize();
+ }

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

+ public struct Windows.UI.Xaml.Automation.Peers.UiaRuntimeId {
+ 	public uint Part1;
+ 	public uint Part2;
+ }

| public class Windows.UI.Xaml.Controls.AppBar : Windows.UI.Xaml.Controls.ContentControl {
+ 	public AppBarClosedDisplayMode ClosedDisplayMode { get; set; }
+ 	public DependencyProperty ClosedDisplayModeProperty { get; }
| }

+ public enum Windows.UI.Xaml.Controls.AppBarClosedDisplayMode {
+ 	Compact = 0,
+ 	Minimal = 1,
+ }

+ public class Windows.UI.Xaml.Controls.AutoSuggestBox : Windows.UI.Xaml.Controls.ItemsControl {
+ 	public bool UpdateTextOnSelect { get; set; }
+ 	public string TextMemberPath { get; set; }
+ 	public Style TextBoxStyle { get; set; }
+ 	public string Text { get; set; }
+ 	public string PlaceholderText { get; set; }
+ 	public double MaxSuggestionListHeight { get; set; }
+ 	public bool IsSuggestionListOpen { get; set; }
+ 	public object Header { get; set; }
+ 	public bool AutoMaximizeSuggestionArea { get; set; }
+ 	public DependencyProperty AutoMaximizeSuggestionAreaProperty { get; }
+ 	public DependencyProperty HeaderProperty { get; }
+ 	public DependencyProperty IsSuggestionListOpenProperty { get; }
+ 	public DependencyProperty MaxSuggestionListHeightProperty { get; }
+ 	public DependencyProperty PlaceholderTextProperty { get; }
+ 	public DependencyProperty TextBoxStyleProperty { get; }
+ 	public DependencyProperty TextMemberPathProperty { get; }
+ 	public DependencyProperty TextProperty { get; }
+ 	public DependencyProperty UpdateTextOnSelectProperty { get; }
+ 	public AutoSuggestBox();
+ 	TypedEventHandler<AutoSuggestBox, AutoSuggestBoxSuggestionChosenEventArgs> SuggestionChosen;
+ 	TypedEventHandler<AutoSuggestBox, AutoSuggestBoxTextChangedEventArgs> TextChanged;
+ }

+ public class Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs : Windows.UI.Xaml.DependencyObject {
+ 	public object SelectedItem { get; }
+ 	public DependencyProperty SelectedItemProperty { get; }
+ 	public AutoSuggestBoxSuggestionChosenEventArgs();
+ }

+ public void delegate Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventHandler( AutoSuggestBox sender, AutoSuggestBoxSuggestionChosenEventArgs e );

+ public class Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs : Windows.UI.Xaml.DependencyObject {
+ 	public AutoSuggestionBoxTextChangeReason Reason { get; set; }
+ 	public DependencyProperty ReasonProperty { get; }
+ 	public AutoSuggestBoxTextChangedEventArgs();
+ 	public bool CheckCurrent();
+ }

+ public void delegate Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventHandler( AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs e );

+ public enum Windows.UI.Xaml.Controls.AutoSuggestionBoxTextChangeReason {
+ 	UserInput = 0,
+ 	ProgrammaticChange = 1,
+ 	SuggestionChosen = 2,
+ }

+ public class Windows.UI.Xaml.Controls.ChooseItemContainerEventArgs {
+ 	public SelectorItem ItemContainer { get; set; }
+ 	public bool Handled { get; set; }
+ 	public object Item { get; }
+ 	public int ItemIndex { get; }
+ 	public ChooseItemContainerEventArgs();
+ }

+ public enum Windows.UI.Xaml.Controls.ClosedCaptionKind {
+ 	Caption = 0,
+ 	Subtitle = 1,
+ 	Metadata = 2,
+ }

+ public class Windows.UI.Xaml.Controls.ClosedCaptionTrack {
+ 	public Uri SourceUri { get; set; }
+ 	public string Language { get; set; }
+ 	public string Label { get; set; }
+ 	public ClosedCaptionKind Kind { get; set; }
+ 	public bool IsDefault { get; set; }
+ 	public ClosedCaptionTrack();
+ }

+ public class Windows.UI.Xaml.Controls.ContentDialog : Windows.UI.Xaml.Controls.ContentControl {
+ 	public DataTemplate TitleTemplate { get; set; }
+ 	public object Title { get; set; }
+ 	public string SecondaryButtonText { get; set; }
+ 	public object SecondaryButtonCommandParameter { get; set; }
+ 	public ICommand SecondaryButtonCommand { get; set; }
+ 	public string PrimaryButtonText { get; set; }
+ 	public object PrimaryButtonCommandParameter { get; set; }
+ 	public ICommand PrimaryButtonCommand { get; set; }
+ 	public bool IsSecondaryButtonEnabled { get; set; }
+ 	public bool IsPrimaryButtonEnabled { get; set; }
+ 	public bool FullSizeDesired { get; set; }
+ 	public DependencyProperty FullSizeDesiredProperty { get; }
+ 	public DependencyProperty IsPrimaryButtonEnabledProperty { get; }
+ 	public DependencyProperty IsSecondaryButtonEnabledProperty { get; }
+ 	public DependencyProperty PrimaryButtonCommandParameterProperty { get; }
+ 	public DependencyProperty PrimaryButtonCommandProperty { get; }
+ 	public DependencyProperty PrimaryButtonTextProperty { get; }
+ 	public DependencyProperty SecondaryButtonCommandParameterProperty { get; }
+ 	public DependencyProperty SecondaryButtonCommandProperty { get; }
+ 	public DependencyProperty SecondaryButtonTextProperty { get; }
+ 	public DependencyProperty TitleProperty { get; }
+ 	public DependencyProperty TitleTemplateProperty { get; }
+ 	public ContentDialog();
+ 	public void Hide();
+ 	public IAsyncOperation<ContentDialogResult> ShowAsync();
+ 	TypedEventHandler<ContentDialog, ContentDialogClosedEventArgs> Closed;
+ 	TypedEventHandler<ContentDialog, ContentDialogClosingEventArgs> Closing;
+ 	TypedEventHandler<ContentDialog, ContentDialogOpenedEventArgs> Opened;
+ 	TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> PrimaryButtonClick;
+ 	TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> SecondaryButtonClick;
+ }

+ public class Windows.UI.Xaml.Controls.ContentDialogButtonClickDeferral {
+ 	public void Complete();
+ }

+ public class Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs {
+ 	public bool Cancel { get; set; }
+ 	public ContentDialogButtonClickDeferral GetDeferral();
+ }

+ public class Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs {
+ 	public ContentDialogResult Result { get; }
+ }

+ public class Windows.UI.Xaml.Controls.ContentDialogClosingDeferral {
+ 	public void Complete();
+ }

+ public class Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs {
+ 	public bool Cancel { get; set; }
+ 	public ContentDialogResult Result { get; }
+ 	public ContentDialogClosingDeferral GetDeferral();
+ }

+ public class Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs {
+ }

+ public enum Windows.UI.Xaml.Controls.ContentDialogResult {
+ 	None = 0,
+ 	Primary = 1,
+ 	Secondary = 2,
+ }

| public class Windows.UI.Xaml.Controls.ContentPresenter : Windows.UI.Xaml.FrameworkElement {
+ 	public bool IsTextScaleFactorEnabled { get; set; }
+ 	public TextWrapping TextWrapping { get; set; }
+ 	public int MaxLines { get; set; }
+ 	public LineStackingStrategy LineStackingStrategy { get; set; }
+ 	public DependencyProperty IsTextScaleFactorEnabledProperty { get; }
+ 	public DependencyProperty TextWrappingProperty { get; }
+ 	public DependencyProperty MaxLinesProperty { get; }
+ 	public DependencyProperty LineStackingStrategyProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.Control : Windows.UI.Xaml.FrameworkElement {
+ 	public bool IsTextScaleFactorEnabled { get; set; }
+ 	public Style ValidationIndicatorStyle { get; set; }
+ 	public bool IsValidationIndicatorEnabled { get; set; }
+ 	public IObservableVector<ControlValidationError> ValidationErrors { get; }
+ 	public ControlValidationState ValidationState { get; }
+ 	public DependencyProperty IsValidationIndicatorEnabledProperty { get; }
+ 	public DependencyProperty ValidationErrorsProperty { get; }
+ 	public DependencyProperty ValidationIndicatorStyleProperty { get; }
+ 	public DependencyProperty ValidationStateProperty { get; }
+ 	public DependencyProperty IsTextScaleFactorEnabledProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.ControlValidationError {
+ 	public IIterable<string> PropertyNames { get; set; }
+ 	public string Message { get; set; }
+ 	public ControlValidationError();
+ }

+ public enum Windows.UI.Xaml.Controls.ControlValidationState {
+ 	Unknown = 0,
+ 	Valid = 1,
+ 	Invalid = 2,
+ }

+ public class Windows.UI.Xaml.Controls.DatePickedEventArgs : Windows.UI.Xaml.DependencyObject {
+ 	public DateTime NewDate { get; }
+ 	public DateTime OldDate { get; }
+ 	public DatePickedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.DatePickerFlyout : Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase {
+ 	public bool YearVisible { get; set; }
+ 	public bool MonthVisible { get; set; }
+ 	public DateTime MinYear { get; set; }
+ 	public DateTime MaxYear { get; set; }
+ 	public bool DayVisible { get; set; }
+ 	public DateTime Date { get; set; }
+ 	public string CalendarIdentifier { get; set; }
+ 	public DependencyProperty CalendarIdentifierProperty { get; }
+ 	public DependencyProperty DateProperty { get; }
+ 	public DependencyProperty DayVisibleProperty { get; }
+ 	public DependencyProperty MaxYearProperty { get; }
+ 	public DependencyProperty MinYearProperty { get; }
+ 	public DependencyProperty MonthVisibleProperty { get; }
+ 	public DependencyProperty YearVisibleProperty { get; }
+ 	public DatePickerFlyout();
+ 	public IAsyncOperation<IReference<DateTime>> ShowAtAsync( FrameworkElement returnValue );
+ 	TypedEventHandler<DatePickerFlyout, DatePickedEventArgs> DatePicked;
+ }

+ public class Windows.UI.Xaml.Controls.DatePickerFlyoutItem : Windows.UI.Xaml.DependencyObject {
+ 	public string SecondaryText { get; set; }
+ 	public string PrimaryText { get; set; }
+ 	public TypeName Type { get; }
+ 	public DependencyProperty PrimaryTextProperty { get; }
+ 	public DependencyProperty SecondaryTextProperty { get; }
+ 	public ICustomProperty GetCustomProperty( string returnValue );
+ 	public ICustomProperty GetIndexedProperty( string returnValue, TypeName name );
+ 	public string GetStringRepresentation();
+ }

+ public class Windows.UI.Xaml.Controls.DatePickerFlyoutPresenter : Windows.UI.Xaml.Controls.Control {
+ }

+ public class Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs {
+ 	public DataPackageOperation DropStatus { get; }
+ 	public IVectorView<object> Items { get; }
+ 	public DragItemsCompletedEventArgs();
+ }

+ public void delegate Windows.UI.Xaml.Controls.DragItemsCompletedEventHandler( object sender, DragItemsCompletedEventArgs e );

| public class Windows.UI.Xaml.Controls.FontIcon : Windows.UI.Xaml.Controls.IconElement {
+ 	public bool IsTextScaleFactorEnabled { get; set; }
+ 	public DependencyProperty IsTextScaleFactorEnabledProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.ItemsPickedEventArgs : Windows.UI.Xaml.DependencyObject {
+ 	public IVector<object> AddedItems { get; }
+ 	public IVector<object> RemovedItems { get; }
+ 	public ItemsPickedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.ListPickerFlyout : Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase {
+ 	public ListPickerFlyoutSelectionMode SelectionMode { get; set; }
+ 	public string SelectedValuePath { get; set; }
+ 	public object SelectedValue { get; set; }
+ 	public object SelectedItem { get; set; }
+ 	public int SelectedIndex { get; set; }
+ 	public object ItemsSource { get; set; }
+ 	public DataTemplate ItemTemplate { get; set; }
+ 	public string DisplayMemberPath { get; set; }
+ 	public IVector<object> SelectedItems { get; }
+ 	public DependencyProperty DisplayMemberPathProperty { get; }
+ 	public DependencyProperty ItemTemplateProperty { get; }
+ 	public DependencyProperty ItemsSourceProperty { get; }
+ 	public DependencyProperty SelectedIndexProperty { get; }
+ 	public DependencyProperty SelectedItemProperty { get; }
+ 	public DependencyProperty SelectedValuePathProperty { get; }
+ 	public DependencyProperty SelectedValueProperty { get; }
+ 	public DependencyProperty SelectionModeProperty { get; }
+ 	public ListPickerFlyout();
+ 	public IAsyncOperation<IVectorView<object>> ShowAtAsync( FrameworkElement returnValue );
+ 	TypedEventHandler<ListPickerFlyout, ItemsPickedEventArgs> ItemsPicked;
+ }

+ public class Windows.UI.Xaml.Controls.ListPickerFlyoutPresenter : Windows.UI.Xaml.Controls.Control {
+ }

+ public enum Windows.UI.Xaml.Controls.ListPickerFlyoutSelectionMode {
+ 	Single = 0,
+ 	Multiple = 1,
+ }

| public class Windows.UI.Xaml.Controls.ListViewBase : Windows.UI.Xaml.Controls.Primitives.Selector {
+ 	public ListViewReorderMode ReorderMode { get; set; }
+ 	public DependencyProperty ReorderModeProperty { get; }
| }

+ public enum Windows.UI.Xaml.Controls.ListViewReorderMode {
+ 	Disabled = 0,
+ 	Enabled = 1,
+ }

| public class Windows.UI.Xaml.Controls.MediaElement : Windows.UI.Xaml.FrameworkElement {
+ 	public MediaTransportControls TransportControls { get; set; }
+ 	public IVector<ClosedCaptionTrack> ClosedCaptionTracks { get; set; }
| }

+ public class Windows.UI.Xaml.Controls.MediaTransportControls : Windows.UI.Xaml.Controls.Control {
+ 	public bool IsZoomEnabled { get; set; }
+ 	public bool IsZoomButtonVisible { get; set; }
+ 	public bool IsVolumeEnabled { get; set; }
+ 	public bool IsVolumeButtonVisible { get; set; }
+ 	public bool IsStopEnabled { get; set; }
+ 	public bool IsStopButtonVisible { get; set; }
+ 	public bool IsSeekEnabled { get; set; }
+ 	public bool IsSeekBarVisible { get; set; }
+ 	public bool IsPlaybackRateEnabled { get; set; }
+ 	public bool IsPlaybackRateButtonVisible { get; set; }
+ 	public bool IsFullWindowEnabled { get; set; }
+ 	public bool IsFullWindowButtonVisible { get; set; }
+ 	public bool IsFastRewindEnabled { get; set; }
+ 	public bool IsFastRewindButtonVisible { get; set; }
+ 	public bool IsFastForwardEnabled { get; set; }
+ 	public bool IsFastForwardButtonVisible { get; set; }
+ 	public DependencyProperty IsFastForwardButtonVisibleProperty { get; }
+ 	public DependencyProperty IsFastForwardEnabledProperty { get; }
+ 	public DependencyProperty IsFastRewindButtonVisibleProperty { get; }
+ 	public DependencyProperty IsFastRewindEnabledProperty { get; }
+ 	public DependencyProperty IsFullWindowButtonVisibleProperty { get; }
+ 	public DependencyProperty IsFullWindowEnabledProperty { get; }
+ 	public DependencyProperty IsPlaybackRateButtonVisibleProperty { get; }
+ 	public DependencyProperty IsPlaybackRateEnabledProperty { get; }
+ 	public DependencyProperty IsSeekBarVisibleProperty { get; }
+ 	public DependencyProperty IsSeekEnabledProperty { get; }
+ 	public DependencyProperty IsStopButtonVisibleProperty { get; }
+ 	public DependencyProperty IsStopEnabledProperty { get; }
+ 	public DependencyProperty IsVolumeButtonVisibleProperty { get; }
+ 	public DependencyProperty IsVolumeEnabledProperty { get; }
+ 	public DependencyProperty IsZoomButtonVisibleProperty { get; }
+ 	public DependencyProperty IsZoomEnabledProperty { get; }
+ 	public MediaTransportControls();
+ }

| public class Windows.UI.Xaml.Controls.Page : Windows.UI.Xaml.Controls.UserControl {
+ 	public IVector<KeyAccelerator> KeyAccelerators { get; }
| }

+ public class Windows.UI.Xaml.Controls.PickerConfirmedEventArgs : Windows.UI.Xaml.DependencyObject {
+ 	public PickerConfirmedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.PickerFlyout : Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase {
+ 	public UIElement Content { get; set; }
+ 	public bool ConfirmationButtonsVisible { get; set; }
+ 	public DependencyProperty ConfirmationButtonsVisibleProperty { get; }
+ 	public DependencyProperty ContentProperty { get; }
+ 	public PickerFlyout();
+ 	public IAsyncOperation<bool> ShowAtAsync( FrameworkElement returnValue );
+ 	TypedEventHandler<PickerFlyout, PickerConfirmedEventArgs> Confirmed;
+ }

+ public class Windows.UI.Xaml.Controls.PickerFlyoutPresenter : Windows.UI.Xaml.Controls.ContentControl {
+ }

+ public class Windows.UI.Xaml.Controls.Pivot : Windows.UI.Xaml.Controls.ItemsControl {
+ 	public DataTemplate TitleTemplate { get; set; }
+ 	public object Title { get; set; }
+ 	public object SelectedItem { get; set; }
+ 	public int SelectedIndex { get; set; }
+ 	public bool IsLocked { get; set; }
+ 	public DataTemplate HeaderTemplate { get; set; }
+ 	public DependencyProperty HeaderTemplateProperty { get; }
+ 	public DependencyProperty IsLockedProperty { get; }
+ 	public DependencyProperty SelectedIndexProperty { get; }
+ 	public DependencyProperty SelectedItemProperty { get; }
+ 	public DependencyProperty SlideInAnimationGroupProperty { get; }
+ 	public DependencyProperty TitleProperty { get; }
+ 	public DependencyProperty TitleTemplateProperty { get; }
+ 	public Pivot();
+ 	public static PivotSlideInAnimationGroup GetSlideInAnimationGroup( FrameworkElement value );
+ 	public static void SetSlideInAnimationGroup( FrameworkElement element, PivotSlideInAnimationGroup value );
+ 	TypedEventHandler<Pivot, PivotItemEventArgs> PivotItemLoaded;
+ 	TypedEventHandler<Pivot, PivotItemEventArgs> PivotItemLoading;
+ 	TypedEventHandler<Pivot, PivotItemEventArgs> PivotItemUnloaded;
+ 	TypedEventHandler<Pivot, PivotItemEventArgs> PivotItemUnloading;
+ 	Windows.UI.Xaml.Controls.SelectionChangedEventHandler SelectionChanged;
+ }

+ public class Windows.UI.Xaml.Controls.PivotItem : Windows.UI.Xaml.Controls.ContentControl {
+ 	public object Header { get; set; }
+ 	public DependencyProperty HeaderProperty { get; }
+ 	public PivotItem();
+ }

+ public class Windows.UI.Xaml.Controls.PivotItemEventArgs {
+ 	public PivotItem Item { get; set; }
+ 	public PivotItemEventArgs();
+ }

+ public enum Windows.UI.Xaml.Controls.PivotSlideInAnimationGroup {
+ 	Default = 0,
+ 	GroupOne = 1,
+ 	GroupTwo = 2,
+ 	GroupThree = 3,
+ }

| public class Windows.UI.Xaml.Controls.RichTextBlock : Windows.UI.Xaml.FrameworkElement {
+ 	public bool IsTextScaleFactorEnabled { get; set; }
+ 	public DependencyProperty IsTextScaleFactorEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.TextBlock : Windows.UI.Xaml.FrameworkElement {
+ 	public bool IsTextScaleFactorEnabled { get; set; }
+ 	public DependencyProperty IsTextScaleFactorEnabledProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.TimePickedEventArgs : Windows.UI.Xaml.DependencyObject {
+ 	public TimeSpan NewTime { get; }
+ 	public TimeSpan OldTime { get; }
+ 	public TimePickedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.TimePickerFlyout : Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase {
+ 	public TimeSpan Time { get; set; }
+ 	public int MinuteIncrement { get; set; }
+ 	public string ClockIdentifier { get; set; }
+ 	public DependencyProperty ClockIdentifierProperty { get; }
+ 	public DependencyProperty MinuteIncrementProperty { get; }
+ 	public DependencyProperty TimeProperty { get; }
+ 	public TimePickerFlyout();
+ 	public IAsyncOperation<IReference<TimeSpan>> ShowAtAsync( FrameworkElement returnValue );
+ 	TypedEventHandler<TimePickerFlyout, TimePickedEventArgs> TimePicked;
+ }

+ public class Windows.UI.Xaml.Controls.TimePickerFlyoutPresenter : Windows.UI.Xaml.Controls.Control {
+ }

+ public class Windows.UI.Xaml.Controls.ValidationIndicator : Windows.UI.Xaml.Controls.Control {
+ 	public Control Target { get; }
+ 	public ValidationIndicator();
+ }

| public class Windows.UI.Xaml.Controls.WebView : Windows.UI.Xaml.FrameworkElement {
+ 	public bool ContainsFullScreenElement { get; }
+ 	public DependencyProperty ContainsFullScreenElementProperty { get; }
+ 	public void AddApplicationObject( string name, object pObject );
| }

+ public class Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource : Windows.UI.Xaml.Controls.Maps.MapTileDataSource {
+ 	public CustomMapTileDataSource();
+ 	TypedEventHandler<CustomMapTileDataSource, MapTileBitmapRequestedEventArgs> BitmapRequested;
+ }

+ public class Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource : Windows.UI.Xaml.Controls.Maps.MapTileDataSource {
+ 	public string UriFormatString { get; set; }
+ 	public bool AllowCaching { get; set; }
+ 	public IMap<string, string> AdditionalRequestHeaders { get; }
+ 	public HttpMapTileDataSource();
+ 	public HttpMapTileDataSource( string uriFormatString );
+ 	TypedEventHandler<HttpMapTileDataSource, MapTileUriRequestedEventArgs> UriRequested;
+ }

+ public class Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource : Windows.UI.Xaml.Controls.Maps.MapTileDataSource {
+ 	public string UriFormatString { get; set; }
+ 	public LocalMapTileDataSource();
+ 	public LocalMapTileDataSource( string uriFormatString );
+ 	TypedEventHandler<LocalMapTileDataSource, MapTileUriRequestedEventArgs> UriRequested;
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapAnimationKind {
+ 	Default = 0,
+ 	None = 1,
+ 	Linear = 2,
+ 	Bow = 3,
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapColorScheme {
+ 	Light = 0,
+ 	Dark = 1,
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapControl : Windows.UI.Xaml.Controls.Control {
+ 	public double ZoomLevel { get; set; }
+ 	public MapWatermarkMode WatermarkMode { get; set; }
+ 	public Point TransformOrigin { get; set; }
+ 	public bool TrafficFlowVisible { get; set; }
+ 	public MapStyle Style { get; set; }
+ 	public bool PedestrianFeaturesVisible { get; set; }
+ 	public string MapServiceToken { get; set; }
+ 	public bool LandmarksVisible { get; set; }
+ 	public double Heading { get; set; }
+ 	public double DesiredPitch { get; set; }
+ 	public MapColorScheme ColorScheme { get; set; }
+ 	public Geopoint Center { get; set; }
+ 	public IVector<DependencyObject> Children { get; }
+ 	public MapLoadingStatus LoadingStatus { get; }
+ 	public IVector<MapElement> MapElements { get; }
+ 	public double MaxZoomLevel { get; }
+ 	public double MinZoomLevel { get; }
+ 	public double Pitch { get; }
+ 	public IVector<MapRouteView> Routes { get; }
+ 	public IVector<MapTileSource> TileSources { get; }
+ 	public DependencyProperty CenterProperty { get; }
+ 	public DependencyProperty ZoomLevelProperty { get; }
+ 	public DependencyProperty ChildrenProperty { get; }
+ 	public DependencyProperty ColorSchemeProperty { get; }
+ 	public DependencyProperty DesiredPitchProperty { get; }
+ 	public DependencyProperty HeadingProperty { get; }
+ 	public DependencyProperty LandmarksVisibleProperty { get; }
+ 	public DependencyProperty LoadingStatusProperty { get; }
+ 	public DependencyProperty LocationProperty { get; }
+ 	public DependencyProperty MapElementsProperty { get; }
+ 	public DependencyProperty MapServiceTokenProperty { get; }
+ 	public DependencyProperty NormalizedAnchorPointProperty { get; }
+ 	public DependencyProperty PedestrianFeaturesVisibleProperty { get; }
+ 	public DependencyProperty PitchProperty { get; }
+ 	public DependencyProperty RoutesProperty { get; }
+ 	public DependencyProperty StyleProperty { get; }
+ 	public DependencyProperty TileSourcesProperty { get; }
+ 	public DependencyProperty TrafficFlowVisibleProperty { get; }
+ 	public DependencyProperty TransformOriginProperty { get; }
+ 	public DependencyProperty WatermarkModeProperty { get; }
+ 	public MapControl();
+ 	public IVectorView<MapElement> FindMapElementsAtOffset( Point returnValue );
+ 	public void GetLocationFromOffset( Point offset, ref Geopoint location );
+ 	public void GetOffsetFromLocation( Geopoint location, ref Point offset );
+ 	public void IsLocationInView( Geopoint location, ref bool isInView );
+ 	public IAsyncOperation<bool> TrySetViewBoundsAsync( GeoboundingBox returnValue, IReference<Thickness> bounds, MapAnimationKind margin );
+ 	public IAsyncOperation<bool> TrySetViewAsync( Geopoint returnValue );
+ 	public IAsyncOperation<bool> TrySetViewAsync( Geopoint returnValue, IReference<double> center );
+ 	public IAsyncOperation<bool> TrySetViewAsync( Geopoint returnValue, IReference<double> center, IReference<double> zoomLevel, IReference<double> heading );
+ 	public IAsyncOperation<bool> TrySetViewAsync( Geopoint returnValue, IReference<double> center, IReference<double> zoomLevel, IReference<double> heading, MapAnimationKind desiredPitch );
+ 	public static Geopoint GetLocation( DependencyObject value );
+ 	public static void SetLocation( DependencyObject element, Geopoint value );
+ 	public static Point GetNormalizedAnchorPoint( DependencyObject value );
+ 	public static void SetNormalizedAnchorPoint( DependencyObject element, Point value );
+ 	TypedEventHandler<MapControl, object> CenterChanged;
+ 	TypedEventHandler<MapControl, object> HeadingChanged;
+ 	TypedEventHandler<MapControl, object> LoadingStatusChanged;
+ 	TypedEventHandler<MapControl, MapInputEventArgs> MapDoubleTapped;
+ 	TypedEventHandler<MapControl, MapInputEventArgs> MapHolding;
+ 	TypedEventHandler<MapControl, MapInputEventArgs> MapTapped;
+ 	TypedEventHandler<MapControl, object> PitchChanged;
+ 	TypedEventHandler<MapControl, object> TransformOriginChanged;
+ 	TypedEventHandler<MapControl, object> ZoomLevelChanged;
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapElement : Windows.UI.Xaml.DependencyObject {
+ 	public int ZIndex { get; set; }
+ 	public bool Visible { get; set; }
+ 	public DependencyProperty VisibleProperty { get; }
+ 	public DependencyProperty ZIndexProperty { get; }
+ 	public MapElement();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapIcon : Windows.UI.Xaml.Controls.Maps.MapElement {
+ 	public string Title { get; set; }
+ 	public Point NormalizedAnchorPoint { get; set; }
+ 	public Geopoint Location { get; set; }
+ 	public IRandomAccessStreamReference Image { get; set; }
+ 	public DependencyProperty LocationProperty { get; }
+ 	public DependencyProperty NormalizedAnchorPointProperty { get; }
+ 	public DependencyProperty TitleProperty { get; }
+ 	public MapIcon();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapInputEventArgs : Windows.UI.Xaml.DependencyObject {
+ 	public Geopoint Location { get; }
+ 	public Point Position { get; }
+ 	public MapInputEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapItemsControl : Windows.UI.Xaml.DependencyObject {
+ 	public object ItemsSource { get; set; }
+ 	public DataTemplate ItemTemplate { get; set; }
+ 	public IVector<DependencyObject> Items { get; }
+ 	public DependencyProperty ItemTemplateProperty { get; }
+ 	public DependencyProperty ItemsProperty { get; }
+ 	public DependencyProperty ItemsSourceProperty { get; }
+ 	public MapItemsControl();
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapLoadingStatus {
+ 	Loading = 0,
+ 	Loaded = 1,
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapPolygon : Windows.UI.Xaml.Controls.Maps.MapElement {
+ 	public double StrokeThickness { get; set; }
+ 	public bool StrokeDashed { get; set; }
+ 	public Color StrokeColor { get; set; }
+ 	public Geopath Path { get; set; }
+ 	public Color FillColor { get; set; }
+ 	public DependencyProperty PathProperty { get; }
+ 	public DependencyProperty StrokeDashedProperty { get; }
+ 	public DependencyProperty StrokeThicknessProperty { get; }
+ 	public MapPolygon();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapPolyline : Windows.UI.Xaml.Controls.Maps.MapElement {
+ 	public double StrokeThickness { get; set; }
+ 	public bool StrokeDashed { get; set; }
+ 	public Color StrokeColor { get; set; }
+ 	public Geopath Path { get; set; }
+ 	public DependencyProperty PathProperty { get; }
+ 	public DependencyProperty StrokeDashedProperty { get; }
+ 	public MapPolyline();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapRouteView : Windows.UI.Xaml.DependencyObject {
+ 	public Color RouteColor { get; set; }
+ 	public Color OutlineColor { get; set; }
+ 	public MapRoute Route { get; }
+ 	public MapRouteView( MapRoute route );
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapStyle {
+ 	None = 0,
+ 	Road = 1,
+ 	Aerial = 2,
+ 	AerialWithRoads = 3,
+ 	Terrain = 4,
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequest {
+ 	public IRandomAccessStreamReference PixelData { get; set; }
+ 	public MapTileBitmapRequest();
+ 	public MapTileBitmapRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestDeferral {
+ 	public MapTileBitmapRequestDeferral();
+ 	public void Complete();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs {
+ 	public MapTileBitmapRequest Request { get; }
+ 	public int X { get; }
+ 	public int Y { get; }
+ 	public int ZoomLevel { get; }
+ 	public MapTileBitmapRequestedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileDataSource : Windows.UI.Xaml.DependencyObject {
+ 	public MapTileDataSource();
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapTileLayer {
+ 	LabelOverlay = 0,
+ 	RoadOverlay = 1,
+ 	AreaOverlay = 2,
+ 	BackgroundOverlay = 3,
+ 	BackgroundReplacement = 4,
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileSource : Windows.UI.Xaml.DependencyObject {
+ 	public MapZoomLevelRange ZoomLevelRange { get; set; }
+ 	public int ZIndex { get; set; }
+ 	public bool Visible { get; set; }
+ 	public int TilePixelSize { get; set; }
+ 	public MapTileLayer Layer { get; set; }
+ 	public bool IsTransparencyEnabled { get; set; }
+ 	public bool IsRetryEnabled { get; set; }
+ 	public bool IsFadingEnabled { get; set; }
+ 	public MapTileDataSource DataSource { get; set; }
+ 	public GeoboundingBox Bounds { get; set; }
+ 	public bool AllowOverstretch { get; set; }
+ 	public DependencyProperty AllowOverstretchProperty { get; }
+ 	public DependencyProperty BoundsProperty { get; }
+ 	public DependencyProperty DataSourceProperty { get; }
+ 	public DependencyProperty IsFadingEnabledProperty { get; }
+ 	public DependencyProperty IsRetryEnabledProperty { get; }
+ 	public DependencyProperty IsTransparencyEnabledProperty { get; }
+ 	public DependencyProperty LayerProperty { get; }
+ 	public DependencyProperty TilePixelSizeProperty { get; }
+ 	public DependencyProperty VisibleProperty { get; }
+ 	public DependencyProperty ZIndexProperty { get; }
+ 	public DependencyProperty ZoomLevelRangeProperty { get; }
+ 	public MapTileSource();
+ 	public MapTileSource( MapTileDataSource dataSource );
+ 	public MapTileSource( MapTileDataSource dataSource, MapZoomLevelRange zoomLevelRange );
+ 	public MapTileSource( MapTileDataSource dataSource, MapZoomLevelRange zoomLevelRange, GeoboundingBox bounds );
+ 	public MapTileSource( MapTileDataSource dataSource, MapZoomLevelRange zoomLevelRange, GeoboundingBox bounds, int tileSizeInPixels );
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileUriRequest {
+ 	public Uri Uri { get; set; }
+ 	public MapTileUriRequest();
+ 	public MapTileUriRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileUriRequestDeferral {
+ 	public MapTileUriRequestDeferral();
+ 	public void Complete();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs {
+ 	public MapTileUriRequest Request { get; }
+ 	public int X { get; }
+ 	public int Y { get; }
+ 	public int ZoomLevel { get; }
+ 	public MapTileUriRequestedEventArgs();
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapWatermarkMode {
+ 	Automatic = 0,
+ 	On = 1,
+ }

+ public struct Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange {
+ 	public double Min;
+ 	public double Max;
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter : Windows.UI.Xaml.DependencyObject {
+ 	public Brush Enabled { get; set; }
+ 	public Brush Disabled { get; set; }
+ 	public DependencyProperty DisabledProperty { get; }
+ 	public DependencyProperty EnabledProperty { get; }
+ 	public JumpListItemBackgroundConverter();
+ 	public object Convert( object returnValue, TypeName value, object targetType, string parameter );
+ 	public object ConvertBack( object returnValue, TypeName value, object targetType, string parameter );
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter : Windows.UI.Xaml.DependencyObject {
+ 	public Brush Enabled { get; set; }
+ 	public Brush Disabled { get; set; }
+ 	public DependencyProperty DisabledProperty { get; }
+ 	public DependencyProperty EnabledProperty { get; }
+ 	public JumpListItemForegroundConverter();
+ 	public object Convert( object returnValue, TypeName value, object targetType, string parameter );
+ 	public object ConvertBack( object returnValue, TypeName value, object targetType, string parameter );
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.LoopingSelector : Windows.UI.Xaml.Controls.Control {
+ 	public bool ShouldLoop { get; set; }
+ 	public object SelectedItem { get; set; }
+ 	public int SelectedIndex { get; set; }
+ 	public IVector<object> Items { get; set; }
+ 	public int ItemWidth { get; set; }
+ 	public DataTemplate ItemTemplate { get; set; }
+ 	public int ItemHeight { get; set; }
+ 	public DependencyProperty ItemHeightProperty { get; }
+ 	public DependencyProperty ItemTemplateProperty { get; }
+ 	public DependencyProperty ItemWidthProperty { get; }
+ 	public DependencyProperty ItemsProperty { get; }
+ 	public DependencyProperty SelectedIndexProperty { get; }
+ 	public DependencyProperty SelectedItemProperty { get; }
+ 	public DependencyProperty ShouldLoopProperty { get; }
+ 	Windows.UI.Xaml.Controls.SelectionChangedEventHandler SelectionChanged;
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.LoopingSelectorItem : Windows.UI.Xaml.Controls.ContentControl {
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel : Windows.UI.Xaml.Controls.Canvas {
+ 	public bool AreHorizontalSnapPointsRegular { get; }
+ 	public bool AreVerticalSnapPointsRegular { get; }
+ 	public IVectorView<float> GetIrregularSnapPoints( Orientation returnValue, SnapPointsAlignment orientation );
+ 	public float GetRegularSnapPoints( Orientation returnValue, SnapPointsAlignment orientation, ref float alignment );
+ 	EventHandler<object> HorizontalSnapPointsChanged;
+ 	EventHandler<object> VerticalSnapPointsChanged;
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase : Windows.UI.Xaml.Controls.Primitives.FlyoutBase {
+ 	public DependencyProperty TitleProperty { get; }
+ 	protected PickerFlyoutBase();
+ 	protected void OnConfirmed();
+ 	protected bool ShouldShowConfirmationButtons();
+ 	public static string GetTitle( DependencyObject value );
+ 	public static void SetTitle( DependencyObject element, string value );
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.PivotHeaderItem : Windows.UI.Xaml.Controls.ContentControl {
+ 	public PivotHeaderItem();
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.PivotHeaderPanel : Windows.UI.Xaml.Controls.Panel {
+ 	public PivotHeaderPanel();
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.PivotPanel : Windows.UI.Xaml.Controls.Panel {
+ 	public bool AreHorizontalSnapPointsRegular { get; }
+ 	public bool AreVerticalSnapPointsRegular { get; }
+ 	public PivotPanel();
+ 	public IVectorView<float> GetIrregularSnapPoints( Orientation returnValue, SnapPointsAlignment orientation );
+ 	public float GetRegularSnapPoints( Orientation returnValue, SnapPointsAlignment orientation, ref float alignment );
+ 	EventHandler<object> HorizontalSnapPointsChanged;
+ 	EventHandler<object> VerticalSnapPointsChanged;
+ }

+ public interface Windows.UI.Xaml.Data.IItemsRangeInfo {
+ 	public void RangesChanged( ItemIndexRange visibleRange, IVectorView<ItemIndexRange> trackedItems );
+ }

+ public interface Windows.UI.Xaml.Data.IItemsRangeInfoFactory {
+ 	public IItemsRangeInfo CreateItemsRangeInfo();
+ }

+ public class Windows.UI.Xaml.Data.ItemIndexRange {
+ 	public int FirstIndex { get; }
+ 	public int LastIndex { get; }
+ 	public uint Length { get; }
+ 	public ItemIndexRange( int firstIndex, uint length );
+ }

| public class Windows.UI.Xaml.Documents.Glyphs : Windows.UI.Xaml.FrameworkElement {
+ 	public bool IsColorFontEnabled { get; set; }
+ 	public int ColorFontPaletteIndex { get; set; }
+ 	public DependencyProperty ColorFontPaletteIndexProperty { get; }
+ 	public DependencyProperty IsColorFontEnabledProperty { get; }
| }

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

| public class Windows.UI.Xaml.Input.FocusManager {
+ 	public static UIElement FindNextFocus( FocusNavigationDirection result );
+ 	public static UIElement FindNextFocus( FocusNavigationDirection result, Rect focusNavigationDirection );
| }

| public enum Windows.UI.Xaml.Input.FocusNavigationDirection {
+ 	Up = 2,
+ 	Down = 3,
+ 	Left = 4,
+ 	Right = 5,
+ 	None = 6,
| }

+ public class Windows.UI.Xaml.Input.GettingFocusEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ 	public UIElement NewFocus { get; set; }
+ 	public bool Handled { get; set; }
+ 	public FocusNavigationDirection FocusNavigationDirection { get; }
+ 	public UIElement OldFocus { get; }
+ }

+ public class Windows.UI.Xaml.Input.LosingFocusEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ 	public UIElement NewFocus { get; set; }
+ 	public bool Handled { get; set; }
+ 	public FocusNavigationDirection FocusNavigationDirection { get; }
+ 	public UIElement OldFocus { get; }
+ }

+ public class Windows.UI.Xaml.Media.Animation.CommonNavigationTransitionInfo : Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo {
+ 	public bool IsStaggeringEnabled { get; set; }
+ 	public DependencyProperty IsStaggerElementProperty { get; }
+ 	public DependencyProperty IsStaggeringEnabledProperty { get; }
+ 	public CommonNavigationTransitionInfo();
+ 	public static bool GetIsStaggerElement( UIElement value );
+ 	public static void SetIsStaggerElement( UIElement element, bool value );
+ }

+ public class Windows.UI.Xaml.Media.Animation.ContinuumNavigationTransitionInfo : Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo {
+ 	public UIElement ExitElement { get; set; }
+ 	public DependencyProperty ExitElementContainerProperty { get; }
+ 	public DependencyProperty ExitElementProperty { get; }
+ 	public DependencyProperty IsEntranceElementProperty { get; }
+ 	public DependencyProperty IsExitElementProperty { get; }
+ 	public ContinuumNavigationTransitionInfo();
+ 	public static bool GetIsEntranceElement( UIElement value );
+ 	public static void SetIsEntranceElement( UIElement element, bool value );
+ 	public static bool GetIsExitElement( UIElement value );
+ 	public static void SetIsExitElement( UIElement element, bool value );
+ 	public static bool GetExitElementContainer( ListViewBase value );
+ 	public static void SetExitElementContainer( ListViewBase element, bool value );
+ }

+ public class Windows.UI.Xaml.Media.Animation.NavigationThemeTransition : Windows.UI.Xaml.Media.Animation.Transition {
+ 	public NavigationTransitionInfo DefaultNavigationTransitionInfo { get; set; }
+ 	public DependencyProperty DefaultNavigationTransitionInfoProperty { get; }
+ 	public NavigationThemeTransition();
+ }

+ public class Windows.UI.Xaml.Media.Animation.SlideNavigationTransitionInfo : Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo {
+ 	public SlideNavigationTransitionInfo();
+ }

+ public class Windows.UI.Xaml.Media.Imaging.XamlRenderingBackgroundTask {
+ 	protected XamlRenderingBackgroundTask();
+ 	protected void OnRun( IBackgroundTaskInstance taskInstance );
+ }


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

 new file: Windows 10/Windows.Web.winmd
 old file: Windows 8.1 Update/Windows.Web.winmd

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