WinMetdata Diff 9879 - 9901

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

 new file: new\Windows.ApplicationModel.winmd
 old file: old\Windows.ApplicationModel.winmd

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

| public class Windows.ApplicationModel.Package {
+ 	public DateTime InstallDate { get; }
+ 	public string GetThumbnailToken();
+ 	public void Launch( string parameters );
| }

| public class Windows.ApplicationModel.PackageId {
+ 	public string Author { get; }
+ 	public string ProductId { get; }
| }

+ public struct Windows.ApplicationModel.Activation.ActivatedEventsContract {
+ }

| public enum Windows.ApplicationModel.Activation.ActivationKind {
+ 	VoiceCommand = 16,
+ 	PickerReturned = 1000,
+ 	WalletAction = 1001,
+ 	WebAuthenticationBrokerContinuation = 1005,
+ 	ProtocolWithResultsContinuation = 1009,
+ 	ProtocolForResults = 1010,
| }

+ public class Windows.ApplicationModel.Activation.AppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public string Verb { get; }
+ 	public IReference<DateTime> InstanceStartDate { get; }
+ 	public string LocalId { get; }
+ 	public string RoamingId { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+ 	public IReference<DateTime> InstanceStartDate { get; }
+ 	public string LocalId { get; }
+ 	public string RoamingId { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IFolderActivatedEventArgs {
+ 	public IStorageFolder Folder { get; }
+ 	public IVectorView<IStorageItem> SelectedItems { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IPickerReturnedActivatedEventArgs {
+ 	public string PickerOperationId { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData {
+ 	public string CallerPackageFamilyName { get; }
+ 	public ValueSet Data { get; }
+ }

* public interface Windows.ApplicationModel.Activation.ISplashScreen;

+ public interface Windows.ApplicationModel.Activation.IVoiceCommandActivatedEventArgs {
+ 	public SpeechRecognitionResult Result { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IWalletActionActivatedEventArgs {
+ 	public string ActionId { get; }
+ 	public WalletActionKind ActionKind { get; }
+ 	public string ItemId { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IWebAuthenticationBrokerContinuationEventArgs {
+ 	public WebAuthenticationResult WebAuthenticationResult { get; }
+ }

+ public class Windows.ApplicationModel.Activation.PickerReturnedActivatedEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public string PickerOperationId { get; }
+ }

+ public class Windows.ApplicationModel.Activation.ProtocolForResultsActivatedEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public int CurrentlyShownApplicationViewId { get; }
+ 	public Uri Uri { get; }
+ 	public string CallerPackageFamilyName { get; }
+ 	public ValueSet Data { get; }
+ 	public ProtocolForResultsOperation ProtocolForResultsOperation { get; }
+ }

+ public class Windows.ApplicationModel.Activation.ProtocolWithResultsContinuationActivatedEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public ValueSet Result { get; }
+ }

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

+ public class Windows.ApplicationModel.Activation.WalletActionActivatedEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public string ActionId { get; }
+ 	public WalletActionKind ActionKind { get; }
+ 	public string ItemId { get; }
+ }

+ public class Windows.ApplicationModel.Activation.WebAuthenticationBrokerContinuationEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public WebAuthenticationResult WebAuthenticationResult { get; }
+ }

| public class Windows.ApplicationModel.Appointments.Appointment {
+ 	public ulong ServerChangeNumber { get; set; }
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncAdapter {
+ 	public AppointmentCalendarSyncState CurrentState { get; }
+ 	public DateTime LastAttemptedSyncTime { get; }
+ 	public DateTime LastSuccessfulSyncTime { get; }
+ 	public IAsyncOperation<bool> SyncAsync();
+ 	TypedEventHandler<AppointmentCalendar, AppointmentCalendarSyncStatusChangedEventArgs> SyncStatusChanged;
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentCalendarSyncState {
+ 	Unknown = 0,
+ 	Idle = 1,
+ 	Syncing = 2,
+ 	Disconnected = 3,
+ 	Throttled = 4,
+ 	UserAttentionRequired = 5,
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncStatusChangedEventArgs {
+ 	public AppointmentCalendarSyncState CurrentState { get; }
+ 	public DateTime LastAttemptedSyncTime { get; }
+ 	public DateTime LastSuccessfulSyncTime { get; }
+ }

| public class Windows.ApplicationModel.Appointments.AppointmentProperties {
+ 	public string ServerChangeNumber { get; }
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentStoreNotificationTriggerDetails {
+ }

| public class Windows.ApplicationModel.Appointments.AppointmentsProvider.AppointmentsProviderLaunchActionVerbs {
+ 	public string ShowAppointmentDetails { get; }
| }

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

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

+ public class Windows.ApplicationModel.Background.CachedFileUpdaterTriggerDetails {
+ 	public bool CanRequestUserInput { get; }
+ 	public FileUpdateRequest UpdateRequest { get; }
+ 	public CachedFileTarget UpdateTarget { get; }
+ }

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

+ public class Windows.ApplicationModel.Background.DeviceManufacturerNotificationTrigger {
+ 	public bool OneShot { get; }
+ 	public string TriggerQualifier { get; }
+ 	public DeviceManufacturerNotificationTrigger( string triggerQualifier, bool oneShot );
+ }

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

+ public class Windows.ApplicationModel.Background.PhoneTrigger {
+ 	public bool OneShot { get; }
+ 	public PhoneTriggerType TriggerType { get; }
+ 	public PhoneTrigger( PhoneTriggerType type, bool oneShot );
+ }

+ public class Windows.ApplicationModel.Background.SensorDataThresholdTrigger {
+ 	public SensorDataThresholdTrigger( ISensorDataThreshold threshold );
+ }

+ public class Windows.ApplicationModel.Background.SmartCardTrigger {
+ 	public SmartCardTriggerType TriggerType { get; }
+ 	public SmartCardTrigger( SmartCardTriggerType triggerType );
+ }

+ public class Windows.ApplicationModel.Background.ToastNotificationHistoryChangedTrigger {
+ 	public ToastNotificationHistoryChangedTrigger( string applicationId );
+ 	public ToastNotificationHistoryChangedTrigger();
+ }

+ public struct Windows.ApplicationModel.Calls.LockScreenCallContract {
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogEntry {
+ 	public bool IsEmergency { get; set; }
+ 	public bool IsCallerIdBlocked { get; set; }
+ 	public bool IsSeen { get; set; }
+ 	public IReference<TimeSpan> Duration { get; set; }
+ 	public PhoneCallLogEntryDirection Direction { get; set; }
+ 	public PhoneCallLogEntryAddress Address { get; set; }
+ 	public DateTime StartTime { get; set; }
+ 	public string RemoteId { get; set; }
+ 	public PhoneCallLogEntryKind Kind { get; set; }
+ 	public bool IsVoicemail { get; set; }
+ 	public bool IsSuppressed { get; set; }
+ 	public string Id { get; }
+ 	public string ProviderId { get; }
+ 	public PhoneCallLogEntry();
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogEntryAddress {
+ 	public string RawAddress { get; set; }
+ 	public string DisplayName { get; set; }
+ 	public PhoneCallLogEntryAddress();
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogEntryDirection {
+ 	Outgoing = 0,
+ 	IncomingAnswered = 1,
+ 	IncomingMissed = 2,
+ 	IncomingRinging = 3,
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogEntryKind {
+ 	CellularAudio = 0,
+ 	CellularVideo = 1,
+ 	VoipAudio = 2,
+ 	VoipVideo = 3,
+ 	VoipPstn = 4,
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogEntryMatchReason {
+ 	public PhoneCallLogEntryMatchReasonField MatchedField { get; }
+ 	public IVectorView<TextSegment> MatchedSegments { get; }
+ 	public string MatchedText { get; }
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogEntryMatchReasonField {
+ 	DisplayName = 0,
+ 	RawAddress = 1,
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogEntryQuery {
+ 	public string SearchText { get; set; }
+ 	public PhoneCallLogEntryQueryKinds Kinds { get; set; }
+ 	public PhoneCallLogEntryQueryDirections Directions { get; set; }
+ 	public IVector<string> PhoneCallLogEntryProviderIds { get; }
+ 	public PhoneCallLogEntryQuery();
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogEntryQueryDirections {
+ 	None = 0,
+ 	Outgoing = 1,
+ 	IncomingAnswered = 2,
+ 	IncomingMissed = 4,
+ 	IncomingRinging = 8,
+ 	All = 4294967295,
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogEntryQueryKinds {
+ 	None = 0,
+ 	CellularAudio = 1,
+ 	CellularVideo = 2,
+ 	VoipAudio = 4,
+ 	VoipVideo = 8,
+ 	VoipPstn = 16,
+ 	All = 4294967295,
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogEntryReader {
+ 	public IVectorView<PhoneCallLogEntryMatchReason> GetMatchingPropertiesWithMatchReason( PhoneCallLogEntry result );
+ 	public IAsyncOperation<IVectorView<PhoneCallLogEntry>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogManager {
+ 	public static IAsyncOperation<PhoneCallLogStore> RequestCallLogStoreAsync( PhoneCallLogStoreAccessType result );
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogProvider {
+ 	public PhoneCallLogProviderOtherAppWriteAccess OtherAppWriteAccess { get; set; }
+ 	public PhoneCallLogProviderOtherAppReadAccess OtherAppReadAccess { get; set; }
+ 	public string DisplayName { get; set; }
+ 	public string Id { get; }
+ 	public string SourceDisplayName { get; }
+ 	public IAsyncAction SaveAsync();
+ 	public IAsyncAction DeleteAsync();
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogProviderOtherAppReadAccess {
+ 	SystemOnly = 0,
+ 	Full = 1,
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogProviderOtherAppWriteAccess {
+ 	None = 0,
+ 	Limited = 1,
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallLogStore {
+ 	public IAsyncOperation<PhoneCallLogEntry> GetPhoneCallLogEntryAsync( string result );
+ 	public PhoneCallLogEntryReader GetCallLogEntryReader();
+ 	public PhoneCallLogEntryReader GetCallLogEntryReader( PhoneCallLogEntryQuery result );
+ 	public IAsyncAction SavePhoneCallLogEntryAsync( PhoneCallLogEntry result );
+ 	public IAsyncAction MarkPhoneCallLogEntriesAsSeenAsync( IVector<PhoneCallLogEntry> result );
+ 	public IAsyncAction MarkPhoneCallLogEntryAsSeenAsync( PhoneCallLogEntry result );
+ 	public IAsyncAction DeletePhoneCallLogEntriesAsync( IVector<PhoneCallLogEntry> result );
+ 	public IAsyncAction DeletePhoneCallLogEntryAsync( PhoneCallLogEntry result );
+ 	public IAsyncOperation<PhoneCallLogProvider> CreatePhoneCallLogProviderAsync( string result );
+ 	public IAsyncOperation<PhoneCallLogProvider> GetPhoneCallLogProviderAsync();
+ 	public IAsyncOperation<IVectorView<PhoneCallLogProvider>> GetPhoneCallLogProvidersAsync();
+ 	public IAsyncOperation<uint> GetPhoneCallLogProvidersUnseenCountAsync( IVectorView<PhoneCallLogProvider> result );
+ 	public IAsyncOperation<uint> GetPhoneCallLogProvidersUnseenCountAsync();
+ 	public IAsyncAction MarkPhoneCallLogProvidersAsSeenAsync( IVectorView<PhoneCallLogProvider> result );
+ 	public IAsyncAction MarkPhoneCallLogProvidersAsSeenAsync();
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneCallLogStoreAccessType {
+ 	AppProvidersReadWrite = 0,
+ 	AllProvidersReadOnly = 1,
+ 	AllProvidersReadWrite = 2,
+ }

| public class Windows.ApplicationModel.Calls.PhoneCallStore {
+ 	public PhoneLineWatcher RequestLineWatcher();
| }

| public class Windows.ApplicationModel.Calls.PhoneLine {
+ 	public bool SupportsTile { get; }
| }

+ public class Windows.ApplicationModel.Calls.PhoneLineWatcher {
+ 	public PhoneLineWatcherStatus Status { get; }
+ 	public void Start();
+ 	public void Stop();
+ 	TypedEventHandler<PhoneLineWatcher, object> EnumerationCompleted;
+ 	TypedEventHandler<PhoneLineWatcher, PhoneLineWatcherEventArgs> LineAdded;
+ 	TypedEventHandler<PhoneLineWatcher, PhoneLineWatcherEventArgs> LineRemoved;
+ 	TypedEventHandler<PhoneLineWatcher, PhoneLineWatcherEventArgs> LineUpdated;
+ 	TypedEventHandler<PhoneLineWatcher, object> Stopped;
+ }

+ public class Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs {
+ 	public Guid LineId { get; }
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneLineWatcherStatus {
+ 	Created = 0,
+ 	Started = 1,
+ 	EnumerationCompleted = 2,
+ 	Stopped = 3,
+ 	Aborted = 4,
+ }

| public class Windows.ApplicationModel.Calls.PhoneVoicemail {
- 	public void ShowVisualVoicemailUI();
| }

+ public class Windows.ApplicationModel.Calls.Background.PhoneCallStateChangedTriggerDetails {
+ 	public uint ActiveCallCount { get; }
+ 	public uint EndedCallCount { get; }
+ 	public uint IncomingCallCount { get; }
+ }

+ public enum Windows.ApplicationModel.Calls.Background.PhoneLineChangeType {
+ 	Added = 0,
+ 	Removed = 1,
+ 	Changed = 2,
+ }

+ public class Windows.ApplicationModel.Calls.Background.PhoneLineChangedTriggerDetails {
+ 	public PhoneLineChangeType ChangeType { get; }
+ 	public Guid LineId { get; }
+ 	public bool HasLinePropertyChanged( PhoneLineProperties pResult );
+ }

+ public enum Windows.ApplicationModel.Calls.Background.PhoneLineProperties {
+ 	None = 0,
+ 	BrandingOptions = 1,
+ 	CanDial = 2,
+ 	CellularDetails = 4,
+ 	DisplayColor = 8,
+ 	Name = 16,
+ 	NetworkName = 32,
+ 	NetworkState = 64,
+ 	Transport = 128,
+ 	Voicemail = 256,
+ }

+ public enum Windows.ApplicationModel.Calls.Background.PhoneTriggerType {
+ 	CallStateChanged = 0,
+ 	NewVoicemailMessage = 1,
+ 	CallHistoryChanged = 2,
+ 	LineChanged = 3,
+ 	AirplaneModeDisabledForEmergencyCall = 4,
+ }

+ public class Windows.ApplicationModel.Calls.Background.PhoneVoicemailCountChangedTriggerDetails {
+ 	public Guid LineId { get; }
+ 	public uint VoicemailCount { get; }
+ 	public string VoicemailMessage { get; }
+ }

| public class Windows.ApplicationModel.ContactsTemp.Contact {
+ 	public bool IsDisplayPictureManuallySet { get; }
- 	public bool IsDisplayPictureIsManuallySet { get; }
| }

| public enum Windows.ApplicationModel.ContactsTemp.ContactBatchStatus {
+ 	ServerSearchPartnershipError = 1,
- 	UserActionableError = 1,
- 	InactionableError = 2,
| }

| public class Windows.ApplicationModel.ContactsTemp.ContactList {
+ 	public bool SupportsServerSearch { get; }
+ 	public ContactListSyncAdapter SyncAdapter { get; }
| }

+ public class Windows.ApplicationModel.ContactsTemp.ContactListSyncAdapter {
+ 	public ContactListSyncState CurrentState { get; }
+ 	public DateTime LastAttemptedSyncTime { get; }
+ 	public DateTime LastSuccessfulSyncTime { get; }
+ 	public IAsyncOperation<bool> SyncAsync();
+ 	TypedEventHandler<ContactList, ContactListSyncStatusChangedEventArgs> SyncStatusChanged;
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactListSyncState {
+ 	Unknown = 0,
+ 	Idle = 1,
+ 	Syncing = 2,
+ 	Disconnected = 3,
+ 	Throttled = 4,
+ 	UserAttentionRequired = 5,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactListSyncStatusChangedEventArgs {
+ 	public ContactListSyncState CurrentState { get; }
+ 	public DateTime LastAttemptedSyncTime { get; }
+ 	public DateTime LastSuccessfulSyncTime { get; }
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactStoreNotificationTriggerDetails {
+ }

+ public class Windows.ApplicationModel.CrossSystem.PeerSystem {
+ 	public string Name { get; }
+ 	public ValueSet Properties { get; }
+ }

+ public class Windows.ApplicationModel.CrossSystem.PeerSystemQuery {
+ 	public IIterable<string> UriSchemes { get; }
+ 	public IAsyncOperation<IIterable<PeerSystem>> FindAsync();
+ }

+ public class Windows.ApplicationModel.DataTransfer.SharedStorageAccessManager {
+ 	public static string AddFile( IStorageFile outToken );
+ 	public static IAsyncOperation<StorageFile> RedeemTokenForFileAsync( string operation );
+ 	public static void RemoveFile( string token );
+ }

+ public enum Windows.ApplicationModel.DataTransfer.DragDrop.DragUIOptions {
+ 	None = 0,
+ 	SuppressAdornments = 1,
+ }

| public class Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragOperation {
- 	public IVector<uint> PointerIds { get; }
+ 	public void SetPointerId( uint pointerId );
+ 	public void SetDragUIContent( object dragContent, Size contentSize );
+ 	public void SetDragUIContent( object dragContent, Size contentSize, Point anchorPoint );
- 	public void SetDragUI( object dragContent, Size contentSize, Point anchorPoint );
| }

| public class Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragUI {
* 	public DragUIOptions Options { get; set; }
+ 	public void SetDragUIContentOverride( object dragContent, Size contentSize );
+ 	public void SetDragUIContentOverride( object dragContent, Size contentSize, Point anchorPoint );
+ 	public void ClearDragUIContentOverride();
- 	public void SetContent( object dragContent, IReference<Size> contentSize );
| }

- public enum Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragUIOptions;

- public enum Windows.ApplicationModel.Email.EmailCreateResponseType;

| public class Windows.ApplicationModel.Email.EmailMailbox {
+ 	public bool MustEncryptSmimeMessages { get; }
+ 	public bool MustEncryptUnderLockscreen { get; }
+ 	public bool MustSignSmimeMessages { get; }
+ 	public bool AllowSmimeSoftCerts { get; }
+ 	public bool AllowSmimeEncryptionAlgorithmNegotiation { get; }
+ 	public SmimeEncryptionAlgorithm RequiredSmimeEncryptionAlgorithm { get; }
+ 	public SmimeSigningAlgorithm RequiredSmimeSigningAlgorithm { get; }
+ 	public EmailMailboxSyncAdapter SyncAdapter { get; }
+ 	public IAsyncOperation<EmailMessage> CreateResponseMessageAsync( string result, EmailMessageResponseType messageId, string responseType, EmailMessageBodyType subject, string responseHeaderType );
+ 	public IAsyncAction RespondToMeetingAsync( EmailMessage result, EmailMeetingResponseType meeting, string response, string subject, bool comment );
+ 	public IAsyncAction RespondToMeetingAppointmentAsync( Appointment result, EmailMeetingResponseType meeting, string response, string subject, bool comment );
+ 	public IAsyncAction ForwardMeetingAsync( EmailMessage result, IVector<EmailRecipient> meeting, string recipients, EmailMessageBodyType subject, string forwardHeaderType, string forwardHeader );
+ 	public IAsyncAction ForwardMeetingAppointmentAsync( Appointment result, IVector<EmailRecipient> meeting, string recipients, EmailMessageBodyType subject, string forwardHeaderType, string forwardHeader );
+ 	public IAsyncAction ProposeNewTimeForMeetingAsync( EmailMessage result, DateTime meeting, TimeSpan newStartTime, string newDuration, string subject );
+ 	public IAsyncAction ProposeNewTimeForMeetingAppointmentAsync( Appointment result, DateTime meeting, TimeSpan newStartTime, string newDuration, string subject );
+ 	public IAsyncAction CreateMeetingAsync( AppointmentCalendar result, Appointment calendar );
+ 	public IAsyncAction UpdateMeetingAsync( Appointment result );
- 	public IAsyncAction RemoveMeetingFromCalendarAsync( string result );
| }

| public enum Windows.ApplicationModel.Email.EmailMailboxActionType {
+ 	SendMessage = 5,
+ 	CreateReplyMessage = 6,
+ 	CreateReplyAllMessage = 7,
+ 	CreateForwardMessage = 8,
* 	MoveFolder = 9,
| }

| public enum Windows.ApplicationModel.Email.EmailMailboxCapabilities {
+ 	CanCreateMeetings = 512,
+ 	CanForwardMeetings = 1024,
+ 	CanRespondToMeetings = 2048,
+ 	CanSendNewTimeProposals = 4096,
| }

+ public class Windows.ApplicationModel.Email.EmailMailboxSyncAdapter {
+ 	public EmailMailboxSyncState CurrentState { get; }
+ 	public DateTime LastAttemptedSyncTime { get; }
+ 	public DateTime LastSuccessfulSyncTime { get; }
+ 	public IAsyncOperation<bool> SyncAsync();
+ 	TypedEventHandler<EmailMailbox, EmailMailboxSyncStatusChangedEventArgs> SyncStatusChanged;
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxSyncState {
+ 	Unknown = 0,
+ 	Idle = 1,
+ 	Syncing = 2,
+ 	Disconnected = 3,
+ 	Throttled = 4,
+ 	UserAttentionRequired = 5,
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxSyncStatusChangedEventArgs {
+ 	public EmailMailboxSyncState CurrentState { get; }
+ 	public DateTime LastAttemptedSyncTime { get; }
+ 	public DateTime LastSuccessfulSyncTime { get; }
+ }

| public class Windows.ApplicationModel.Email.EmailMeetingInfo {
+ 	public string Location { get; set; }
+ 	public bool IsResponseRequested { get; set; }
+ 	public bool IsAllDay { get; set; }
+ 	public TimeSpan Duration { get; set; }
+ 	public string AppointmentRoamingId { get; set; }
+ 	public bool AllowNewTimeProposal { get; set; }
+ 	public DateTime StartTime { get; set; }
+ 	public ulong ServerChangeNumber { get; set; }
+ 	public IReference<DateTime> RecurrenceStartTime { get; set; }
+ 	public AppointmentRecurrence Recurrence { get; set; }
+ 	public IReference<DateTime> ProposedStartTime { get; set; }
+ 	public IReference<TimeSpan> ProposedDuration { get; set; }
- 	public IRandomAccessStreamReference ICalendarData { get; set; }
- 	public string AppointmentLocalId { get; set; }
| }

+ public enum Windows.ApplicationModel.Email.EmailMeetingResponseType {
+ 	Accept = 0,
+ 	Decline = 1,
+ 	Tentative = 2,
+ 	Cancel = 3,
+ }

| public class Windows.ApplicationModel.Email.EmailMessage {
- 	public bool IsSendSmart { get; set; }
- 	public uint NewTextSize { get; set; }
- 	public uint OriginalHeaderSize { get; set; }
- 	public uint BaseBodyCodePage { get; }
| }

| public enum Windows.ApplicationModel.Email.EmailMessageBodyType {
+ 	Html = 0,
+ 	PlainText = 1,
- 	HtmlWide = 0,
- 	HtmlNarrow = 1,
- 	PlainTextWide = 2,
- 	PlainTextNarrow = 3,
- 	BaseHtmlWide = 4,
- 	BaseHtmlNarrow = 5,
- 	BasePlainTextWide = 6,
- 	BasePlainTextNarrow = 7,
| }

| public enum Windows.ApplicationModel.Email.EmailSearchFields {
+ 	None = 0,
| }

+ public class Windows.ApplicationModel.Email.EmailStoreNotificationTriggerDetails {
+ }

+ public enum Windows.ApplicationModel.Email.SmimeEncryptionAlgorithm {
+ 	Any = 0,
+ 	TripleDES = 1,
+ 	DES = 2,
+ 	RC2128bit = 3,
+ 	RC264bit = 4,
+ 	RC240bit = 5,
+ }

+ public enum Windows.ApplicationModel.Email.SmimeSigningAlgorithm {
+ 	Any = 0,
+ 	SHA1 = 1,
+ 	MD5 = 2,
+ }

| public class Windows.ApplicationModel.Resources.Core.ResourceCandidate {
+ 	public IAsyncOperation<IRandomAccessStream> GetValueAsStreamAsync();
| }

+ public struct Windows.ApplicationModel.Resources.Core.ResourceLayoutInfo {
+ 	public uint MajorVersion;
+ 	public uint MinorVersion;
+ 	public uint ResourceSubtreeCount;
+ 	public uint NamedResourceCount;
+ 	public int Checksum;
+ }

| public class Windows.ApplicationModel.Resources.Core.ResourceManager {
+ 	public IVectorView<NamedResource> GetAllNamedResourcesForPackage( string table, ResourceLayoutInfo packageName );
+ 	public IVectorView<ResourceMap> GetAllSubtreesForPackage( string table, ResourceLayoutInfo packageName );
| }

+ public struct Windows.ApplicationModel.Resources.Management.ResourceIndexerContract {
+ }

| public class Windows.ApplicationModel.Store.CurrentApp {
+ 	public static IAsyncOperation<ListingInformation> LoadListingInformationByProductIdsAsync( IIterable<string> loadListingOperation );
+ 	public static IAsyncOperation<ListingInformation> LoadListingInformationByKeywordsAsync( IIterable<string> loadListingOperation );
+ 	public static void ReportProductFulfillment( string productId );
| }

| public class Windows.ApplicationModel.Store.ProductLicense {
+ 	public bool IsConsumable { get; }
| }

+ public class Windows.ApplicationModel.Sync.MailContactsCalendarSyncUI {
+ 	public static IAsyncAction ShowAddAsync( IIterable<SyncContentType> showAddAction );
+ 	public static IAsyncAction ShowSettingsAsync( string showSettingsAction );
+ 	public static IAsyncAction ShowErrorsAsync( string showErrorsAction );
+ }

- public class Windows.ApplicationModel.Sync.PimDataGrouping;

- public class Windows.ApplicationModel.Sync.SyncContent;

- public class Windows.ApplicationModel.Sync.SyncContentStatus;

| public enum Windows.ApplicationModel.Sync.SyncContentType {
+ 	Mail = 0,
* 	Contacts = 1,
* 	Calendar = 2,
- 	Email = 0,
- 	Tasks = 3,
| }

- public class Windows.ApplicationModel.Sync.SyncPartnership;

- public class Windows.ApplicationModel.Sync.SyncPartnershipChangeEventArgs;

- public enum Windows.ApplicationModel.Sync.SyncPartnershipChangeKind;

- public enum Windows.ApplicationModel.Sync.SyncPartnershipStatus;

+ public enum Windows.ApplicationModel.Wallet.WalletActionKind {
+ 	OpenItem = 0,
+ 	Transaction = 1,
+ 	MoreTransactions = 2,
+ 	Message = 3,
+ 	Verb = 4,
+ }

+ public struct Windows.ApplicationModel.Wallet.WalletContract {
+ }


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

 new file: new\Windows.Data.winmd
 old file: old\Windows.Data.winmd

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

+ public class Windows.Data.Text.TextConversionGenerator {
+ 	public string ResolvedLanguage { get; }
+ 	public TextConversionGenerator( string languageTag );
+ 	public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result );
+ 	public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result, uint input );
+ }

+ public class Windows.Data.Text.TextPredictionGenerator {
+ 	public string ResolvedLanguage { get; }
+ 	public TextPredictionGenerator( string languageTag );
+ 	public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result );
+ 	public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result, uint input );
+ }

+ public class Windows.Data.Text.TextReverseConversionGenerator {
+ 	public string ResolvedLanguage { get; }
+ 	public TextReverseConversionGenerator( string languageTag );
+ 	public IAsyncOperation<string> ConvertBackAsync( string result );
+ }


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

 new file: new\Windows.Devices.winmd
 old file: old\Windows.Devices.winmd

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

| public class Windows.Devices.AllJoyn.AllJoynAboutData {
* 	public IMap<string, string> AppNames { get; }
* 	public IMap<string, string> Descriptions { get; }
* 	public IMap<string, string> Manufacturers { get; }
| }

| public class Windows.Devices.AllJoyn.AllJoynAboutDataView {
+ 	public static IAsyncOperation<AllJoynAboutDataView> GetDataBySessionPortAsync( string operation, AllJoynBusAttachment uniqueName, ushort busAttachment );
+ 	public static IAsyncOperation<AllJoynAboutDataView> GetDataBySessionPortAsync( string operation, AllJoynBusAttachment uniqueName, ushort busAttachment, Language sessionPort );
- 	public static IAsyncOperation<AllJoynAboutDataView> GetDataAsync( string operation );
- 	public static IAsyncOperation<AllJoynAboutDataView> GetDataAsync( string operation, Language uniqueName );
| }

| public class Windows.Devices.AllJoyn.AllJoynServiceInfo {
+ 	public string ObjectPath { get; }
+ 	public ushort SessionPort { get; }
+ 	public AllJoynServiceInfo( string uniqueName, string objectPath, ushort sessionPort );
| }

| public enum Windows.Devices.Bluetooth.BluetoothError {
+ 	DeviceNotConnected = 3,
| }

- public class Windows.Devices.Casting.AppLaunchCastingSource;

- public class Windows.Devices.Casting.CastingDevice;

- public class Windows.Devices.Casting.CastingDeviceConnection;

- public enum Windows.Devices.Casting.CastingDeviceConnectionError;

- public class Windows.Devices.Casting.CastingDeviceConnectionErrorEventArgs;

- public enum Windows.Devices.Casting.CastingDeviceConnectionState;

- public class Windows.Devices.Casting.CastingDeviceConnectionStateChangedEventArgs;

- public class Windows.Devices.Casting.CastingDeviceProperties;

- public class Windows.Devices.Casting.CastingDeviceSelectedEventArgs;

- public class Windows.Devices.Casting.CastingDeviceSelectorRequest;

- public class Windows.Devices.Casting.CastingDeviceSelectorRequestDeferral;

- public class Windows.Devices.Casting.CastingDeviceSelectorRequestedEventArgs;

- public enum Windows.Devices.Casting.CastingSourceType;

- public enum Windows.Devices.Casting.CastingTypes;

- public class Windows.Devices.Casting.CastingUI;

- public interface Windows.Devices.Casting.ICastingDevice;

- public interface Windows.Devices.Casting.ICastingDeviceStatics;

- public interface Windows.Devices.Casting.ICastingSource;

- public interface Windows.Devices.Casting.ICastingUIStatics;

- public interface Windows.Devices.Casting.IMediaCastingSource;

- public class Windows.Devices.Casting.ImageCastingSource;

- public class Windows.Devices.Casting.MediaElementCastingSource;

- public class Windows.Devices.Casting.MshtmlCastingSource;

- public class Windows.Devices.Casting.StreamCastingSource;

- public class Windows.Devices.Casting.UriCastingSource;

+ public struct Windows.Devices.Custom.CustomDeviceContract {
+ }

| public class Windows.Devices.Geolocation.Geocoordinate {
+ 	public IReference<DateTime> PositionSourceTimestamp { get; }
| }

+ public enum Windows.Devices.Geolocation.GeolocationAccessStatus {
+ 	Unspecified = 0,
+ 	Allowed = 1,
+ 	Denied = 2,
+ }

| public class Windows.Devices.Geolocation.Geolocator {
+ 	public static IAsyncOperation<GeolocationAccessStatus> RequestAccessAsync();
+ 	public static IAsyncOperation<IVectorView<Geoposition>> GetGeopositionHistoryAsync( DateTime result );
+ 	public static IAsyncOperation<IVectorView<Geoposition>> GetGeopositionHistoryAsync( DateTime result, TimeSpan startTime );
| }

+ public class Windows.Devices.Gpio.GpioController {
+ 	public IMapView<uint, GpioPinInfo> Pins { get; }
+ 	public static string GetDeviceSelector();
+ 	public static string GetDeviceSelector( string value );
+ 	public static IAsyncOperation<GpioController> FromIdAsync( string operation );
+ }

+ public enum Windows.Devices.Gpio.GpioInputDriveMode {
+ 	HighImpedance = 0,
+ 	PullUp = 1,
+ 	PullDown = 2,
+ }

+ public class Windows.Devices.Gpio.GpioInputPin {
+ 	public GpioInputDriveMode InputDriveMode { get; }
+ 	public GpioPinValue Value { get; }
+ 	public void Close();
+ }

+ public class Windows.Devices.Gpio.GpioInterruptEventArgs {
+ 	public bool FallingEdge { get; }
+ 	public bool RisingEdge { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Gpio.GpioInterruptPin {
+ 	public bool Enabled { get; set; }
+ 	public GpioInputDriveMode InputDriveMode { get; }
+ 	public GpioInterruptType InterruptType { get; }
+ 	public GpioPinValue Value { get; }
+ 	public void Close();
+ 	TypedEventHandler<GpioInterruptPin, GpioInterruptEventArgs> InterruptRaised;
+ }

+ public enum Windows.Devices.Gpio.GpioInterruptType {
+ 	FallingEdge = 0,
+ 	RisingEdge = 1,
+ 	ActiveLow = 2,
+ 	ActiveHigh = 3,
+ 	ActiveBoth = 4,
+ }

+ public enum Windows.Devices.Gpio.GpioOpenStatus {
+ 	Success = 0,
+ 	SharingViolation = 1,
+ 	UnknownError = 2,
+ }

+ public class Windows.Devices.Gpio.GpioOutputPin {
+ 	public GpioPinValue Value { get; set; }
+ 	public void Close();
+ }

+ public class Windows.Devices.Gpio.GpioPinCapabilities {
+ 	public bool IsInputSupported { get; }
+ 	public bool IsInterruptSupported { get; }
+ 	public bool IsOutputSupported { get; }
+ }

+ public class Windows.Devices.Gpio.GpioPinInfo {
+ 	public GpioPinCapabilities Capabilities { get; }
+ 	public GpioOpenStatus TryOpenInput( GpioSharingMode status, GpioInputDriveMode sharingMode, ref GpioInputPin driveMode );
+ 	public GpioOpenStatus TryOpenOutput( GpioPinValue status, GpioSharingMode initialValue, ref GpioOutputPin sharingMode );
+ 	public GpioOpenStatus TryOpenInterrupt( GpioInterruptType status, GpioSharingMode type, GpioInputDriveMode sharingMode, ref GpioInterruptPin driveMode );
+ }

+ public enum Windows.Devices.Gpio.GpioPinValue {
+ 	Low = 0,
+ 	High = 1,
+ }

+ public enum Windows.Devices.Gpio.GpioSharingMode {
+ 	Shared = 0,
+ 	Exclusive = 1,
+ }

+ public enum Windows.Devices.I2C.I2CAddressingMode {
+ 	SevenBit = 0,
+ 	TenBit = 1,
+ }

+ public enum Windows.Devices.I2C.I2CBusSpeed {
+ 	StandardMode = 0,
+ 	FastMode = 1,
+ }

+ public class Windows.Devices.I2C.I2CConnectionSettings {
+ 	public I2CBusSpeed BusSpeed { get; set; }
+ 	public I2CAddressingMode AddressingMode { get; set; }
+ 	public uint SlaveAddress { get; }
+ 	public I2CConnectionSettings( uint slaveAddress );
+ 	public I2CConnectionSettings( uint slaveAddress, I2CBusSpeed busSpeed );
+ 	public I2CConnectionSettings( uint slaveAddress, I2CBusSpeed busSpeed, I2CAddressingMode addressingMode );
+ }

+ public class Windows.Devices.I2C.I2CDevice {
+ 	public I2CConnectionSettings ConnectionSettings { get; }
+ 	public I2CTransferStatus TryWrite( byte[] status );
+ 	public I2CTransferStatus TryWrite( byte[] status, ref uint data );
+ 	public I2CTransferStatus TryRead( byte[] status );
+ 	public I2CTransferStatus TryRead( byte[] status, ref uint data );
+ 	public I2CTransferStatus TryWriteRead( byte[] status, byte[] writeBuffer );
+ 	public I2CTransferStatus TryWriteRead( byte[] status, byte[] writeBuffer, ref uint readBuffer );
+ 	public void Close();
+ 	public static string GetDeviceSelector();
+ 	public static string GetDeviceSelector( string value );
+ 	public static IAsyncOperation<I2CDevice> CreateDeviceAsync( string operation, I2CConnectionSettings deviceId );
+ }

+ public enum Windows.Devices.I2C.I2CTransferStatus {
+ 	Success = 0,
+ 	UnknownError = 1,
+ 	PartialTransfer = 2,
+ 	SlaveAddressNotAcknowledged = 3,
+ }

| public class Windows.Devices.Input.PointerDevice {
+ 	public uint MaxPointersWithZDistance { get; }
| }

| public class Windows.Devices.PointOfService.CashDrawer {
+ 	public bool IsDrawerOpen { get; }
+ 	public CashDrawerStatus Status { get; }
+ 	public IAsyncOperation<ClaimedCashDrawer> ClaimDrawerAsync();
+ 	public IAsyncOperation<string> GetStatisticsAsync( IIterable<string> operation );
+ 	public CashDrawerEventSource GetDrawerEventSource();
- 	public IAsyncOperation<ClaimedCashDrawer> ClaimCashDrawerAsync();
- 	public IAsyncOperation<IBuffer> RetrieveStatisticsAsync( IIterable<string> operation );
| }

| public class Windows.Devices.PointOfService.CashDrawerCapabilities {
+ 	public bool IsDrawerOpenSensorAvailable { get; }
| }

+ public class Windows.Devices.PointOfService.CashDrawerCloseAlarm {
+ 	public uint BeepFrequency { get; set; }
+ 	public TimeSpan BeepDuration { get; set; }
+ 	public TimeSpan BeepDelay { get; set; }
+ 	public TimeSpan AlarmTimeout { get; set; }
+ 	public IAsyncOperation<bool> StartAsync();
+ 	TypedEventHandler<CashDrawerCloseAlarm, object> AlarmTimeoutExpired;
+ }

+ public class Windows.Devices.PointOfService.CashDrawerClosedEventArgs {
+ 	public CashDrawer CashDrawer { get; }
+ }

+ public class Windows.Devices.PointOfService.CashDrawerEventSource {
+ 	TypedEventHandler<CashDrawerEventSource, CashDrawerClosedEventArgs> DrawerClosed;
+ 	TypedEventHandler<CashDrawerEventSource, CashDrawerOpenedEventArgs> DrawerOpened;
+ }

+ public class Windows.Devices.PointOfService.CashDrawerOpenedEventArgs {
+ 	public CashDrawer CashDrawer { get; }
+ }

| public class Windows.Devices.PointOfService.CashDrawerStatus {
- 	Online = 0;
- 	Off = 1;
- 	Offline = 2;
- 	OffOrOffline = 3;
- 	DrawerClosed = 4;
- 	DrawerOpened = 5;
- 	Extended = 6;
+ 	public uint ExtendedStatus { get; }
+ 	public CashDrawerStatusKind StatusKind { get; }
| }

+ public enum Windows.Devices.PointOfService.CashDrawerStatusKind {
+ 	Online = 0,
+ 	Off = 1,
+ 	Offline = 2,
+ 	OffOrOffline = 3,
+ 	Extended = 4,
+ }

| public class Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs {
- 	public uint ExtendedStatus { get; }
| }

| public class Windows.Devices.PointOfService.ClaimedCashDrawer {
+ 	public bool IsDrawerOpen { get; }
- 	public bool DrawerOpened { get; }
+ 	public IAsyncOperation<bool> OpenDrawerAsync();
+ 	public CashDrawerCloseAlarm CreateDrawerCloseAlarm();
+ 	public IAsyncOperation<bool> EnableAsync();
+ 	public IAsyncOperation<bool> DisableAsync();
+ 	public IAsyncOperation<bool> RetainDeviceAsync();
+ 	public IAsyncOperation<bool> ResetStatisticsAsync( IIterable<string> result );
+ 	public IAsyncOperation<bool> UpdateStatisticsAsync( IIterable<IKeyValuePair<string, string>> result );
- 	public IAsyncAction WaitForDrawerCloseAsync( uint result, uint beepTimeout, uint beepFrequency, uint beepDuration );
- 	public void RetainDevice();
| }

+ public class Windows.Devices.PointOfService.ClaimedJournalPrinter {
+ 	public bool IsLetterQuality { get; set; }
+ 	public PosPrinterColorCartridge ColorCartridge { get; set; }
+ 	public uint CharactersPerLine { get; set; }
+ 	public uint LineSpacing { get; set; }
+ 	public uint LineHeight { get; set; }
+ 	public bool IsCartridgeEmpty { get; }
+ 	public bool IsCartridgeRemoved { get; }
+ 	public bool IsCoverOpen { get; }
+ 	public bool IsHeadCleaning { get; }
+ 	public bool IsPaperEmpty { get; }
+ 	public bool IsPaperNearEnd { get; }
+ 	public bool IsReadyToPrint { get; }
+ 	public uint LineWidth { get; }
+ 	public JournalPrintJob CreateJob();
+ 	public bool ValidateData( string result );
+ }

- public class Windows.Devices.PointOfService.ClaimedPointOfServicePrinter;

+ public class Windows.Devices.PointOfService.ClaimedPosPrinter {
+ 	public PosPrinterMapMode MapMode { get; set; }
+ 	public bool IsCharacterSetMappingEnabled { get; set; }
+ 	public uint CharacterSet { get; set; }
+ 	public string DeviceId { get; }
+ 	public bool IsCoverOpen { get; }
+ 	public bool IsEnabled { get; }
+ 	public ClaimedJournalPrinter Journal { get; }
+ 	public ClaimedReceiptPrinter Receipt { get; }
+ 	public ClaimedSlipPrinter Slip { get; }
+ 	public IAsyncOperation<bool> EnableAsync();
+ 	public IAsyncOperation<bool> DisableAsync();
+ 	public IAsyncOperation<bool> RetainDeviceAsync();
+ 	public IAsyncOperation<bool> ResetStatisticsAsync( IIterable<string> result );
+ 	public IAsyncOperation<bool> UpdateStatisticsAsync( IIterable<IKeyValuePair<string, string>> result );
+ 	public void Close();
+ 	TypedEventHandler<ClaimedPosPrinter, PosPrinterReleaseDeviceRequestedEventArgs> ReleaseDeviceRequested;
+ }

+ public class Windows.Devices.PointOfService.ClaimedReceiptPrinter {
+ 	public uint LinesToPaperCut { get; }
+ 	public Size PageSize { get; }
+ 	public Rect PrintArea { get; }
+ 	public uint SidewaysMaxChars { get; }
+ 	public uint SidewaysMaxLines { get; }
+ 	public uint LineSpacing { get; set; }
+ 	public uint LineHeight { get; set; }
+ 	public bool IsLetterQuality { get; set; }
+ 	public PosPrinterColorCartridge ColorCartridge { get; set; }
+ 	public uint CharactersPerLine { get; set; }
+ 	public bool IsHeadCleaning { get; }
+ 	public bool IsCoverOpen { get; }
+ 	public bool IsPaperEmpty { get; }
+ 	public bool IsPaperNearEnd { get; }
+ 	public bool IsCartridgeRemoved { get; }
+ 	public bool IsReadyToPrint { get; }
+ 	public bool IsCartridgeEmpty { get; }
+ 	public uint LineWidth { get; }
+ 	public ReceiptPrintJob CreateJob();
+ 	public bool ValidateData( string result );
+ }

+ public class Windows.Devices.PointOfService.ClaimedSlipPrinter {
+ 	public uint LinesNearEndToEnd { get; }
+ 	public uint MaxLines { get; }
+ 	public Size PageSize { get; }
+ 	public Rect PrintArea { get; }
+ 	public PosPrinterPrintSide PrintSide { get; }
+ 	public uint SidewaysMaxChars { get; }
+ 	public uint SidewaysMaxLines { get; }
+ 	public uint LineSpacing { get; set; }
+ 	public uint LineHeight { get; set; }
+ 	public bool IsLetterQuality { get; set; }
+ 	public PosPrinterColorCartridge ColorCartridge { get; set; }
+ 	public uint CharactersPerLine { get; set; }
+ 	public bool IsHeadCleaning { get; }
+ 	public bool IsCartridgeEmpty { get; }
+ 	public bool IsPaperEmpty { get; }
+ 	public bool IsCartridgeRemoved { get; }
+ 	public bool IsReadyToPrint { get; }
+ 	public bool IsPaperNearEnd { get; }
+ 	public bool IsCoverOpen { get; }
+ 	public uint LineWidth { get; }
+ 	public void OpenJaws();
+ 	public void CloseJaws();
+ 	public IAsyncOperation<bool> InsertSlipAsync( TimeSpan result );
+ 	public IAsyncOperation<bool> RemoveSlipAsync( TimeSpan result );
+ 	public void ChangePrintSide( PosPrinterPrintSide printSide );
+ 	public SlipPrintJob CreateJob();
+ 	public bool ValidateData( string result );
+ }

+ public interface Windows.Devices.PointOfService.ICashDrawerEventSourceEventArgs {
+ 	public CashDrawer CashDrawer { get; }
+ }

+ public interface Windows.Devices.PointOfService.ICommonClaimedPosPrinterStation {
+ 	public uint CharactersPerLine { get; set; }
+ 	public PosPrinterColorCartridge ColorCartridge { get; set; }
+ 	public bool IsCartridgeEmpty { get; }
+ 	public bool IsCartridgeRemoved { get; }
+ 	public bool IsCoverOpen { get; }
+ 	public bool IsHeadCleaning { get; }
+ 	public bool IsLetterQuality { get; set; }
+ 	public bool IsPaperEmpty { get; }
+ 	public bool IsPaperNearEnd { get; }
+ 	public bool IsReadyToPrint { get; }
+ 	public uint LineHeight { get; set; }
+ 	public uint LineSpacing { get; set; }
+ 	public uint LineWidth { get; }
+ 	public bool ValidateData( string result );
+ }

+ public interface Windows.Devices.PointOfService.ICommonPosPrintStationCapabilities {
+ 	public PosPrinterCartridgeSensors CartridgeSensors { get; }
+ 	public PosPrinterColorCapabilities ColorCartridgeCapabilities { get; }
+ 	public bool IsBoldSupported { get; }
+ 	public bool IsDoubleHighDoubleWidePrintSupported { get; }
+ 	public bool IsDoubleHighPrintSupported { get; }
+ 	public bool IsDoubleWidePrintSupported { get; }
+ 	public bool IsDualColorSupported { get; }
+ 	public bool IsItalicSupported { get; }
+ 	public bool IsPaperEmptySensorSupported { get; }
+ 	public bool IsPaperNearEndSensorSupported { get; }
+ 	public bool IsPrinterPresent { get; }
+ 	public bool IsUnderlineSupported { get; }
+ 	public IVectorView<uint> SupportedCharactersPerLine { get; }
+ }

+ public interface Windows.Devices.PointOfService.ICommonReceiptSlipCapabilities {
+ 	public bool Is180RotationSupported { get; }
+ 	public bool IsBarcodeSupported { get; }
+ 	public bool IsBitmapSupported { get; }
+ 	public bool IsLeft90RotationSupported { get; }
+ 	public bool IsPrintAreaSupported { get; }
+ 	public bool IsRight90RotationSupported { get; }
+ 	public PosPrinterRuledLineCapabilities RuledLineCapabilities { get; }
+ 	public IVectorView<PosPrinterRotation> SupportedBarcodeRotations { get; }
+ 	public IVectorView<PosPrinterRotation> SupportedBitmapRotations { get; }
+ }

+ public interface Windows.Devices.PointOfService.IPosPrinterJob {
+ 	public void Print( string data );
+ 	public void PrintLine( string data );
+ 	public void PrintLine();
+ 	public IAsyncOperation<bool> ExecuteAsync();
+ }

+ public interface Windows.Devices.PointOfService.IReceiptOrSlipJob {
+ 	public void SetBarcodeRotation( PosPrinterRotation value );
+ 	public void SetPrintRotation( PosPrinterRotation value, bool includeBitmaps );
+ 	public void SetPrintArea( Rect value );
+ 	public void SetBitmap( uint bitmapNumber, BitmapFrame bitmap, PosPrinterAlignment alignment );
+ 	public void SetBitmap( uint bitmapNumber, BitmapFrame bitmap, PosPrinterAlignment alignment, uint width );
+ 	public void SetCustomAlignedBitmap( uint bitmapNumber, BitmapFrame bitmap, uint alignmentDistance );
+ 	public void SetCustomAlignedBitmap( uint bitmapNumber, BitmapFrame bitmap, uint alignmentDistance, uint width );
+ 	public void PrintSavedBitmap( uint bitmapNumber );
+ 	public void DrawRuledLine( string positionList, PosPrinterLineDirection lineDirection, uint lineWidth, PosPrinterLineStyle lineStyle, uint lineColor );
+ 	public void PrintBarcode( string data, uint symbology, uint height, uint width, PosPrinterBarcodeTextPosition textPosition, PosPrinterAlignment alignment );
+ 	public void PrintBarcodeCustomAlign( string data, uint symbology, uint height, uint width, PosPrinterBarcodeTextPosition textPosition, uint alignmentDistance );
+ 	public void PrintBitmap( BitmapFrame bitmap, PosPrinterAlignment alignment );
+ 	public void PrintBitmap( BitmapFrame bitmap, PosPrinterAlignment alignment, uint width );
+ 	public void PrintCustomAlignedBitmap( BitmapFrame bitmap, uint alignmentDistance );
+ 	public void PrintCustomAlignedBitmap( BitmapFrame bitmap, uint alignmentDistance, uint width );
+ }

+ public class Windows.Devices.PointOfService.JournalPrintJob {
+ 	public void Print( string data );
+ 	public void PrintLine( string data );
+ 	public void PrintLine();
+ 	public IAsyncOperation<bool> ExecuteAsync();
+ }

+ public class Windows.Devices.PointOfService.JournalPrinterCapabilities {
+ 	public PosPrinterCartridgeSensors CartridgeSensors { get; }
+ 	public PosPrinterColorCapabilities ColorCartridgeCapabilities { get; }
+ 	public bool IsBoldSupported { get; }
+ 	public bool IsDoubleHighDoubleWidePrintSupported { get; }
+ 	public bool IsDoubleHighPrintSupported { get; }
+ 	public bool IsDoubleWidePrintSupported { get; }
+ 	public bool IsDualColorSupported { get; }
+ 	public bool IsItalicSupported { get; }
+ 	public bool IsPaperEmptySensorSupported { get; }
+ 	public bool IsPaperNearEndSensorSupported { get; }
+ 	public bool IsPrinterPresent { get; }
+ 	public bool IsUnderlineSupported { get; }
+ 	public IVectorView<uint> SupportedCharactersPerLine { get; }
+ }

- public class Windows.Devices.PointOfService.PointOfServicePrinter;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterBarcodeTextPosition;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterBitmapWidthType;

- public class Windows.Devices.PointOfService.PointOfServicePrinterCapabilities;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterCartridgeSensorCapabilities;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterCartridgeStateType;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterCharacterSet;

- public class Windows.Devices.PointOfService.PointOfServicePrinterCharacterSetId;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterColorCapabilities;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterErrorLevel;

- public class Windows.Devices.PointOfService.PointOfServicePrinterErrorOccurredEventArgs;

- public class Windows.Devices.PointOfService.PointOfServicePrinterErrorTypes;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterLineDirection;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterLineStyle;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterLogoLocation;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterMapModeType;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterMarkFeedType;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterMarkSensedPaperFeedHandlingCapabilities;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterObjectAlignment;

- public struct Windows.Devices.PointOfService.PointOfServicePrinterPageModeAreaSize;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterPageModeDirectionTypes;

- public struct Windows.Devices.PointOfService.PointOfServicePrinterPageModePrintArea;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterPageModePrintType;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterPageModeTypes;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterPrintSide;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterRotation;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterRuledLineCapabilities;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterStation;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterStatus;

- public class Windows.Devices.PointOfService.PointOfServicePrinterStatusUpdatedEventArgs;

- public enum Windows.Devices.PointOfService.PointOfServicePrinterTransactionMode;

+ public class Windows.Devices.PointOfService.PosPrinter {
+ 	public PosPrinterCapabilities Capabilities { get; }
+ 	public string DeviceId { get; }
+ 	public PosPrinterStatus Status { get; }
+ 	public IVectorView<uint> SupportedCharacterSets { get; }
+ 	public IVectorView<string> SupportedTypeFaces { get; }
+ 	public IAsyncOperation<ClaimedPosPrinter> ClaimPrinterAsync();
+ 	public IAsyncOperation<string> CheckHealthAsync( UnifiedPosHealthCheckLevel operation );
+ 	public IAsyncOperation<string> GetStatisticsAsync( IIterable<string> operation );
+ 	TypedEventHandler<PosPrinter, PosPrinterStatusUpdatedEventArgs> StatusUpdated;
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterAlignment {
+ 	Left = 0,
+ 	Center = 1,
+ 	Right = 2,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterBarcodeTextPosition {
+ 	None = 0,
+ 	Above = 1,
+ 	Below = 2,
+ }

+ public class Windows.Devices.PointOfService.PosPrinterCapabilities {
+ 	public bool CanMapCharacterSet { get; }
+ 	public uint DefaultCharacterSet { get; }
+ 	public bool HasCoverSensor { get; }
+ 	public bool IsStatisticsReportingSupported { get; }
+ 	public bool IsStatisticsUpdatingSupported { get; }
+ 	public bool IsTransactionSupported { get; }
+ 	public JournalPrinterCapabilities Journal { get; }
+ 	public UnifiedPosPowerReportingType PowerReportingType { get; }
+ 	public ReceiptPrinterCapabilities Receipt { get; }
+ 	public SlipPrinterCapabilities Slip { get; }
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterCartridgeSensors {
+ 	None = 0,
+ 	Removed = 1,
+ 	Empty = 2,
+ 	HeadCleaning = 4,
+ 	NearEnd = 8,
+ }

+ public class Windows.Devices.PointOfService.PosPrinterCharacterSetIds {
+ 	public uint Ansi { get; }
+ 	public uint Ascii { get; }
+ 	public uint Utf16LE { get; }
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterColorCapabilities {
+ 	None = 0,
+ 	Primary = 1,
+ 	Custom1 = 2,
+ 	Custom2 = 4,
+ 	Custom3 = 8,
+ 	Custom4 = 16,
+ 	Custom5 = 32,
+ 	Custom6 = 64,
+ 	Cyan = 128,
+ 	Magenta = 256,
+ 	Yellow = 512,
+ 	Full = 1024,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterColorCartridge {
+ 	Unknown = 0,
+ 	Primary = 1,
+ 	Custom1 = 2,
+ 	Custom2 = 3,
+ 	Custom3 = 4,
+ 	Custom4 = 5,
+ 	Custom5 = 6,
+ 	Custom6 = 7,
+ 	Cyan = 8,
+ 	Magenta = 9,
+ 	Yellow = 10,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterLineDirection {
+ 	Horizontal = 0,
+ 	Vertical = 1,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterLineStyle {
+ 	SingleSolid = 0,
+ 	DoubleSolid = 1,
+ 	Broken = 2,
+ 	Chain = 3,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterMapMode {
+ 	Dots = 0,
+ 	Twips = 1,
+ 	English = 2,
+ 	Metric = 3,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterMarkFeedCapabilities {
+ 	None = 0,
+ 	ToTakeUp = 1,
+ 	ToCutter = 2,
+ 	ToCurrentTopOfForm = 4,
+ 	ToNextTopOfForm = 8,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterMarkFeedKind {
+ 	ToTakeUp = 0,
+ 	ToCutter = 1,
+ 	ToCurrentTopOfForm = 2,
+ 	ToNextTopOfForm = 3,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterPrintSide {
+ 	Unknown = 0,
+ 	Side1 = 1,
+ 	Side2 = 2,
+ }

+ public class Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs {
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterRotation {
+ 	Normal = 0,
+ 	Right90 = 1,
+ 	Left90 = 2,
+ 	Rotate180 = 3,
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterRuledLineCapabilities {
+ 	None = 0,
+ 	Horizontal = 1,
+ 	Vertical = 2,
+ }

+ public class Windows.Devices.PointOfService.PosPrinterStatus {
+ 	public uint ExtendedStatus { get; }
+ 	public PosPrinterStatusKind StatusKind { get; }
+ }

+ public enum Windows.Devices.PointOfService.PosPrinterStatusKind {
+ 	Online = 0,
+ 	Off = 1,
+ 	Offline = 2,
+ 	OffOrOffline = 3,
+ 	Extended = 4,
+ }

+ public class Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs {
+ 	public PosPrinterStatus Status { get; }
+ }

+ public class Windows.Devices.PointOfService.ReceiptPrintJob {
+ 	public void MarkFeed( PosPrinterMarkFeedKind kind );
+ 	public void CutPaper( double percentage );
+ 	public void CutPaper();
+ 	public void SetBarcodeRotation( PosPrinterRotation value );
+ 	public void SetPrintRotation( PosPrinterRotation value, bool includeBitmaps );
+ 	public void SetPrintArea( Rect value );
+ 	public void SetBitmap( uint bitmapNumber, BitmapFrame bitmap, PosPrinterAlignment alignment );
+ 	public void SetBitmap( uint bitmapNumber, BitmapFrame bitmap, PosPrinterAlignment alignment, uint width );
+ 	public void SetCustomAlignedBitmap( uint bitmapNumber, BitmapFrame bitmap, uint alignmentDistance );
+ 	public void SetCustomAlignedBitmap( uint bitmapNumber, BitmapFrame bitmap, uint alignmentDistance, uint width );
+ 	public void PrintSavedBitmap( uint bitmapNumber );
+ 	public void DrawRuledLine( string positionList, PosPrinterLineDirection lineDirection, uint lineWidth, PosPrinterLineStyle lineStyle, uint lineColor );
+ 	public void PrintBarcode( string data, uint symbology, uint height, uint width, PosPrinterBarcodeTextPosition textPosition, PosPrinterAlignment alignment );
+ 	public void PrintBarcodeCustomAlign( string data, uint symbology, uint height, uint width, PosPrinterBarcodeTextPosition textPosition, uint alignmentDistance );
+ 	public void PrintBitmap( BitmapFrame bitmap, PosPrinterAlignment alignment );
+ 	public void PrintBitmap( BitmapFrame bitmap, PosPrinterAlignment alignment, uint width );
+ 	public void PrintCustomAlignedBitmap( BitmapFrame bitmap, uint alignmentDistance );
+ 	public void PrintCustomAlignedBitmap( BitmapFrame bitmap, uint alignmentDistance, uint width );
+ 	public void Print( string data );
+ 	public void PrintLine( string data );
+ 	public void PrintLine();
+ 	public IAsyncOperation<bool> ExecuteAsync();
+ }

+ public class Windows.Devices.PointOfService.ReceiptPrinterCapabilities {
+ 	public PosPrinterColorCapabilities ColorCartridgeCapabilities { get; }
+ 	public bool IsBoldSupported { get; }
+ 	public bool IsDoubleHighDoubleWidePrintSupported { get; }
+ 	public bool IsDoubleHighPrintSupported { get; }
+ 	public bool IsDoubleWidePrintSupported { get; }
+ 	public bool IsDualColorSupported { get; }
+ 	public bool IsItalicSupported { get; }
+ 	public bool IsPaperEmptySensorSupported { get; }
+ 	public bool IsPaperNearEndSensorSupported { get; }
+ 	public bool IsPrinterPresent { get; }
+ 	public bool IsUnderlineSupported { get; }
+ 	public IVectorView<uint> SupportedCharactersPerLine { get; }
+ 	public PosPrinterCartridgeSensors CartridgeSensors { get; }
+ 	public bool Is180RotationSupported { get; }
+ 	public IVectorView<PosPrinterRotation> SupportedBarcodeRotations { get; }
+ 	public IVectorView<PosPrinterRotation> SupportedBitmapRotations { get; }
+ 	public bool IsLeft90RotationSupported { get; }
+ 	public bool IsBarcodeSupported { get; }
+ 	public bool IsBitmapSupported { get; }
+ 	public bool IsPrintAreaSupported { get; }
+ 	public bool IsRight90RotationSupported { get; }
+ 	public PosPrinterRuledLineCapabilities RuledLineCapabilities { get; }
+ 	public bool IsStampSupported { get; }
+ 	public PosPrinterMarkFeedCapabilities MarkFeedCapabilities { get; }
+ 	public bool CanCutPaper { get; }
+ }

+ public class Windows.Devices.PointOfService.SlipPrintJob {
+ 	public void SetBarcodeRotation( PosPrinterRotation value );
+ 	public void SetPrintRotation( PosPrinterRotation value, bool includeBitmaps );
+ 	public void SetPrintArea( Rect value );
+ 	public void SetBitmap( uint bitmapNumber, BitmapFrame bitmap, PosPrinterAlignment alignment );
+ 	public void SetBitmap( uint bitmapNumber, BitmapFrame bitmap, PosPrinterAlignment alignment, uint width );
+ 	public void SetCustomAlignedBitmap( uint bitmapNumber, BitmapFrame bitmap, uint alignmentDistance );
+ 	public void SetCustomAlignedBitmap( uint bitmapNumber, BitmapFrame bitmap, uint alignmentDistance, uint width );
+ 	public void PrintSavedBitmap( uint bitmapNumber );
+ 	public void DrawRuledLine( string positionList, PosPrinterLineDirection lineDirection, uint lineWidth, PosPrinterLineStyle lineStyle, uint lineColor );
+ 	public void PrintBarcode( string data, uint symbology, uint height, uint width, PosPrinterBarcodeTextPosition textPosition, PosPrinterAlignment alignment );
+ 	public void PrintBarcodeCustomAlign( string data, uint symbology, uint height, uint width, PosPrinterBarcodeTextPosition textPosition, uint alignmentDistance );
+ 	public void PrintBitmap( BitmapFrame bitmap, PosPrinterAlignment alignment );
+ 	public void PrintBitmap( BitmapFrame bitmap, PosPrinterAlignment alignment, uint width );
+ 	public void PrintCustomAlignedBitmap( BitmapFrame bitmap, uint alignmentDistance );
+ 	public void PrintCustomAlignedBitmap( BitmapFrame bitmap, uint alignmentDistance, uint width );
+ 	public void Print( string data );
+ 	public void PrintLine( string data );
+ 	public void PrintLine();
+ 	public IAsyncOperation<bool> ExecuteAsync();
+ }

+ public class Windows.Devices.PointOfService.SlipPrinterCapabilities {
+ 	public bool IsBoldSupported { get; }
+ 	public bool IsDoubleHighDoubleWidePrintSupported { get; }
+ 	public bool IsDoubleWidePrintSupported { get; }
+ 	public bool IsDoubleHighPrintSupported { get; }
+ 	public bool IsDualColorSupported { get; }
+ 	public bool IsItalicSupported { get; }
+ 	public bool IsPaperEmptySensorSupported { get; }
+ 	public bool IsPaperNearEndSensorSupported { get; }
+ 	public bool IsPrinterPresent { get; }
+ 	public bool IsUnderlineSupported { get; }
+ 	public PosPrinterColorCapabilities ColorCartridgeCapabilities { get; }
+ 	public IVectorView<uint> SupportedCharactersPerLine { get; }
+ 	public PosPrinterCartridgeSensors CartridgeSensors { get; }
+ 	public bool IsBarcodeSupported { get; }
+ 	public IVectorView<PosPrinterRotation> SupportedBitmapRotations { get; }
+ 	public bool IsPrintAreaSupported { get; }
+ 	public IVectorView<PosPrinterRotation> SupportedBarcodeRotations { get; }
+ 	public bool Is180RotationSupported { get; }
+ 	public bool IsBitmapSupported { get; }
+ 	public bool IsLeft90RotationSupported { get; }
+ 	public bool IsRight90RotationSupported { get; }
+ 	public PosPrinterRuledLineCapabilities RuledLineCapabilities { get; }
+ 	public bool IsFullLengthSupported { get; }
+ 	public bool IsBothSidesPrintingSupported { get; }
+ }

+ public struct Windows.Devices.Portable.PotableDeviceContract {
+ }

+ public struct Windows.Devices.Scanners.ScannerDeviceContract {
+ }

+ public class Windows.Devices.Sensors.Altimeter {
+ 	public uint ReportInterval { get; set; }
+ 	public string DeviceId { get; }
+ 	public uint MinimumReportInterval { get; }
+ 	public AltimeterReading GetCurrentReading();
+ 	TypedEventHandler<Altimeter, AltimeterReadingChangedEventArgs> ReadingChanged;
+ }

+ public class Windows.Devices.Sensors.AltimeterReading {
+ 	public double AltitudeChangeInMeters { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.AltimeterReadingChangedEventArgs {
+ 	public AltimeterReading Reading { get; }
+ }

+ public interface Windows.Devices.Sensors.ISensorDataThreshold {
+ }

+ public class Windows.Devices.Sensors.Pedometer {
+ 	public uint ReportInterval { get; set; }
+ 	public string DeviceId { get; }
+ 	public uint MinimumReportInterval { get; }
+ 	public float PowerInMilliwatts { get; }
+ 	public PedometerStatus Status { get; }
+ 	public IVectorView<PedometerReading> GetReadingsFromTriggerDetails( SensorDataThresholdTriggerDetails result );
+ 	TypedEventHandler<Pedometer, PedometerReadingChangedEventArgs> ReadingChanged;
+ 	TypedEventHandler<Pedometer, PedometerStatusChangedEventArgs> StatusChanged;
+ }

+ public class Windows.Devices.Sensors.PedometerDataThreshold {
+ 	public PedometerDataThreshold( Pedometer sensor, int stepGoal );
+ }

+ public class Windows.Devices.Sensors.PedometerReading {
+ 	public int CumulativeSteps { get; }
+ 	public PedometerStepKind StepKind { get; }
+ 	public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.PedometerReadingChangedEventArgs {
+ 	public PedometerReading Reading { get; }
+ }

+ public enum Windows.Devices.Sensors.PedometerStatus {
+ 	Disabled = 0,
+ 	Idle = 1,
+ 	Active = 2,
+ 	Error = 3,
+ }

+ public class Windows.Devices.Sensors.PedometerStatusChangedEventArgs {
+ 	public PedometerStatus Status { get; }
+ }

+ public enum Windows.Devices.Sensors.PedometerStepKind {
+ 	Unknown = 0,
+ 	Walking = 1,
+ 	Running = 2,
+ }

+ public class Windows.Devices.Sensors.SensorDataThresholdTriggerDetails {
+ 	public string DeviceId { get; }
+ 	public SensorType SensorType { get; }
+ }

+ public enum Windows.Devices.Sensors.SensorType {
+ 	Accelerometer = 0,
+ 	ActivitySensor = 1,
+ 	Barometer = 2,
+ 	Compass = 3,
+ 	CustomSensor = 4,
+ 	Gyroscope = 5,
+ 	ProximitySensor = 6,
+ 	Inclinometer = 7,
+ 	LightSensor = 8,
+ 	OrientationSensor = 9,
+ 	Pedometer = 10,
+ 	RelativeInclinometer = 11,
+ 	RelativeOrientationSensor = 12,
+ 	SimpleOrientationSensor = 13,
+ }

- public class Windows.Devices.Serial.DataReceivedEventArgs;

- public class Windows.Devices.Serial.ErrorReceivedEventArgs;

- public class Windows.Devices.Serial.PinChangedEventArgs;

- public enum Windows.Devices.Serial.SerialDataEventType;

- public class Windows.Devices.Serial.SerialDevice;

- public enum Windows.Devices.Serial.SerialErrorEventType;

- public enum Windows.Devices.Serial.SerialHandshake;

- public enum Windows.Devices.Serial.SerialParity;

- public enum Windows.Devices.Serial.SerialPinChangeEventType;

- public enum Windows.Devices.Serial.SerialStopBits;

+ public class Windows.Devices.SerialCommunication.ErrorReceivedEventArgs {
+ 	public SerialError Error { get; }
+ }

+ public class Windows.Devices.SerialCommunication.PinChangedEventArgs {
+ 	public SerialPinChange PinChange { get; }
+ }

+ public class Windows.Devices.SerialCommunication.SerialDevice {
+ 	public bool IsDataTerminalReadyEnabled { get; set; }
+ 	public ushort DataBits { get; set; }
+ 	public SerialHandshake Handshake { get; set; }
+ 	public bool BreakSignalState { get; set; }
+ 	public uint BaudRate { get; set; }
+ 	public TimeSpan WriteTimeout { get; set; }
+ 	public SerialStopBitCount StopBits { get; set; }
+ 	public TimeSpan ReadTimeout { get; set; }
+ 	public SerialParity Parity { get; set; }
+ 	public bool IsRequestToSendEnabled { get; set; }
+ 	public uint BytesReceived { get; }
+ 	public bool CarrierDetectState { get; }
+ 	public bool ClearToSendState { get; }
+ 	public bool DataSetReadyState { get; }
+ 	public IInputStream InputStream { get; }
+ 	public IOutputStream OutputStream { get; }
+ 	public string PortName { get; }
+ 	public ushort UsbProductId { get; }
+ 	public ushort UsbVendorId { get; }
+ 	public void Close();
+ 	public static string GetDeviceSelector( string result );
+ 	public static string GetDeviceSelectorFromUsbVidPid( ushort result, ushort vendorId );
+ 	public static IAsyncOperation<SerialDevice> FromIdAsync( string result );
+ 	TypedEventHandler<SerialDevice, ErrorReceivedEventArgs> ErrorReceived;
+ 	TypedEventHandler<SerialDevice, PinChangedEventArgs> PinChanged;
+ }

+ public enum Windows.Devices.SerialCommunication.SerialError {
+ 	Frame = 0,
+ 	BufferOverrun = 1,
+ 	ReceiveFull = 2,
+ 	ReceiveParity = 3,
+ 	TransmitFull = 4,
+ }

+ public enum Windows.Devices.SerialCommunication.SerialHandshake {
+ 	None = 0,
+ 	RequestToSend = 1,
+ 	XOnXOff = 2,
+ 	RequestToSendXOnXOff = 3,
+ }

+ public enum Windows.Devices.SerialCommunication.SerialParity {
+ 	None = 0,
+ 	Even = 1,
+ 	Odd = 2,
+ 	Mark = 3,
+ 	Space = 4,
+ }

+ public enum Windows.Devices.SerialCommunication.SerialPinChange {
+ 	BreakSignal = 0,
+ 	CarrierDetect = 1,
+ 	ClearToSend = 2,
+ 	DataSetReady = 3,
+ 	RingIndicator = 4,
+ }

+ public enum Windows.Devices.SerialCommunication.SerialStopBitCount {
+ 	None = 0,
+ 	One = 1,
+ 	OnePointFive = 2,
+ 	Two = 3,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardActivationPolicyChangeResult {
+ 	Denied = 0,
+ 	Allowed = 1,
+ }

+ public class Windows.Devices.SmartCards.SmartCardAppletIdGroup {
+ 	public SmartCardEmulationType SmartCardEmulationType { get; set; }
+ 	public SmartCardEmulationCategory SmartCardEmulationCategory { get; set; }
+ 	public string DisplayName { get; set; }
+ 	public IVector<IBuffer> AppletIds { get; }
+ 	public SmartCardAppletIdGroup( string displayName, IVector<IBuffer> appletIds, SmartCardEmulationCategory emulationCategory, SmartCardEmulationType emulationType );
+ }

+ public enum Windows.Devices.SmartCards.SmartCardAppletIdGroupActivationPolicy {
+ 	Disabled = 0,
+ 	ForegroundOverride = 1,
+ 	Enabled = 2,
+ }

+ public class Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration {
+ 	public SmartCardAppletIdGroupActivationPolicy ActivationPolicy { get; }
+ 	public SmartCardAppletIdGroup AppletIdGroup { get; }
+ 	public IAsyncOperation<SmartCardActivationPolicyChangeResult> RequestActivationPolicyChangeAsync( SmartCardAppletIdGroupActivationPolicy result );
+ }

+ public struct Windows.Devices.SmartCards.SmartCardDeviceContract {
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulationCategory {
+ 	Other = 0,
+ 	Payment = 1,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulationType {
+ 	Host = 0,
+ 	Uicc = 1,
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulator {
+ 	public SmartCardEmulatorEnablementPolicy EnablementPolicy { get; }
+ 	public static IAsyncOperation<IVectorView<SmartCardAppletIdGroupRegistration>> GetAppletIdGroupRegistrationsAsync();
+ 	public static IAsyncOperation<SmartCardAppletIdGroupRegistration> RegisterAppletIdGroupAsync( SmartCardAppletIdGroup result );
+ 	public static IAsyncAction UnregisterAppletIdGroupAsync( SmartCardAppletIdGroupRegistration result );
+ 	public static IAsyncOperation<SmartCardEmulator> GetDefaultAsync();
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs {
+ 	public IBuffer CommandApdu { get; }
+ 	public SmartCardEmulatorConnectionProperties ConnectionProperties { get; }
+ 	public IAsyncOperation<bool> TryRespondAsync( IBuffer result );
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs {
+ 	public SmartCardEmulatorConnectionProperties ConnectionProperties { get; }
+ 	public SmartCardEmulatorConnectionDeactivatedReason Reason { get; }
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedReason {
+ 	ConnectionLost = 0,
+ 	ConnectionRedirected = 1,
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulatorConnectionProperties {
+ 	public Guid Id { get; }
+ 	public SmartCardEmulatorConnectionSource Source { get; }
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulatorConnectionSource {
+ 	Unknown = 0,
+ 	NfcReader = 1,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulatorEnablementPolicy {
+ 	Never = 0,
+ 	Always = 1,
+ 	ScreenOn = 2,
+ 	ScreenUnlocked = 3,
+ }

+ public class Windows.Devices.SmartCards.SmartCardTriggerDetails {
+ 	public IBuffer SourceAppletId { get; }
+ 	public IBuffer TriggerData { get; }
+ 	public SmartCardTriggerType TriggerType { get; }
+ }

+ public enum Windows.Devices.SmartCards.SmartCardTriggerType {
+ 	EmulatorTransaction = 0,
+ 	EmulatorNearFieldEntry = 1,
+ 	EmulatorNearFieldExit = 2,
+ }

- public interface Windows.Devices.Sms.ISmsMessage2;

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

| public class Windows.Devices.Sms.SmsDevice2 {
+ 	public string AccountPhoneNumber { get; }
+ 	public CellularClass CellularClass { get; }
+ 	public SmsDeviceStatus DeviceStatus { get; }
+ 	public IAsyncOperation<SmsSendMessageResult> SendMessageAndGetResultAsync( ISmsMessageBase asyncInfo );
| }


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

 new file: new\Windows.Foundation.winmd
 old file: old\Windows.Foundation.winmd

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

+ public struct Windows.Foundation.FoundationContract {
+ }

+ public struct Windows.Foundation.RemoveFromThisBadContract {
+ }

+ public struct Windows.Foundation.UniversalApiContract {
+ }

* internal interface Windows.Foundation.Diagnostics.ILoggingActivity;

* internal interface Windows.Foundation.Diagnostics.ILoggingActivity2;

| public interface Windows.Foundation.Diagnostics.ILoggingTarget {
+ 	public LoggingActivity StartActivity( string result );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields, LoggingOptions level );
| }

| public class Windows.Foundation.Diagnostics.LoggingActivity {
+ 	public LoggingActivity StartActivity( string result );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields, LoggingOptions level );
| }

| public class Windows.Foundation.Diagnostics.LoggingChannel {
+ 	public LoggingActivity StartActivity( string result );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields );
+ 	public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields, LoggingOptions level );
| }

+ public struct Windows.Foundation.Geometry.AlignedBoundingBox {
+ 	public Vector3 Center;
+ 	public Vector3 Extents;
+ }

+ public struct Windows.Foundation.Geometry.Frustum {
+ 	public Plane Top;
+ 	public Plane Bottom;
+ 	public Plane Left;
+ 	public Plane Right;
+ 	public Plane Near;
+ 	public Plane Far;
+ }

+ public struct Windows.Foundation.Geometry.OrientedBoundingBox {
+ 	public AlignedBoundingBox Box;
+ 	public Quaternion Rotation;
+ }

+ public struct Windows.Foundation.Geometry.Ray {
+ 	public Vector3 Start;
+ 	public Vector3 End;
+ }

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

+ public class Windows.Foundation.Metadata.ContractVersionAttribute : System.Attribute {
+ 	public ContractVersionAttribute( uint version );
+ 	public ContractVersionAttribute( Type contract, uint version );
+ }

+ public class Windows.Foundation.Metadata.PreviousContractVersionAttribute : System.Attribute {
+ 	public PreviousContractVersionAttribute( Type contract, uint versionLow, uint versionHigh, Type newContract );
+ 	public PreviousContractVersionAttribute( Type contract, uint versionLow, uint versionHigh );
+ }


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

 new file: new\Windows.Globalization.winmd
 old file: old\Windows.Globalization.winmd

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

| public class Windows.Globalization.CalendarIdentifiers {
+ 	public string Persian { get; }
| }


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

 new file: new\Windows.Graphics.winmd
 old file: old\Windows.Graphics.winmd

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

| public enum Windows.Graphics.DirectX.DirectXPixelFormat {
+ 	Astc4x4Typeless = 133,
+ 	Astc4x4Normalized = 134,
+ 	Astc4x4NormalizedSrgb = 135,
+ 	Astc5x4Typeless = 137,
+ 	Astc5x4Normalized = 138,
+ 	Astc5x4NormalizedSrgb = 139,
+ 	Astc5x5Typeless = 141,
+ 	Astc5x5Normalized = 142,
+ 	Astc5x5NormalizedSrgb = 143,
+ 	Astc6x5Typeless = 145,
+ 	Astc6x5Normalized = 146,
+ 	Astc6x5NormalizedSrgb = 147,
+ 	Astc6x6Typeless = 149,
+ 	Astc6x6Normalized = 150,
+ 	Astc6x6NormalizedSrgb = 151,
+ 	Astc8x5Typeless = 153,
+ 	Astc8x5Normalized = 154,
+ 	Astc8x5NormalizedSrgb = 155,
+ 	Astc8x6Typeless = 157,
+ 	Astc8x6Normalized = 158,
+ 	Astc8x6NormalizedSrgb = 159,
+ 	Astc8x8Typeless = 161,
+ 	Astc8x8Normalized = 162,
+ 	Astc8x8NormalizedSrgb = 163,
+ 	Astc10x5Typeless = 165,
+ 	Astc10x5Normalized = 166,
+ 	Astc10x5NormalizedSrgb = 167,
+ 	Astc10x6Typeless = 169,
+ 	Astc10x6Normalized = 170,
+ 	Astc10x6NormalizedSrgb = 171,
+ 	Astc10x8Typeless = 173,
+ 	Astc10x8Normalized = 174,
+ 	Astc10x8NormalizedSrgb = 175,
+ 	Astc10x10Typeless = 177,
+ 	Astc10x10Normalized = 178,
+ 	Astc10x10NormalizedSrgb = 179,
+ 	Astc12x10Typeless = 181,
+ 	Astc12x10Normalized = 182,
+ 	Astc12x10NormalizedSrgb = 183,
+ 	Astc12x12Typeless = 185,
+ 	Astc12x12Normalized = 186,
+ 	Astc12x12NormalizedSrgb = 187,
| }

| public class Windows.Graphics.Display.DisplayInformation {
+ 	public double RawPixelsPerViewPixel { get; }
| }

+ public class Windows.Graphics.Display.StereoHeadMountedDisplay {
+ 	public double NearPlaneDistance { get; set; }
+ 	public double FarPlaneDistance { get; set; }
+ 	public Person User { get; }
+ 	public PositionalLocatorState State { get; }
+ 	public StereoHeadMountedDisplay();
+ 	public Frustum GetViewFrustum( Pose value );
+ 	public StereoViewProjection GetStereoViewProjection( Pose value );
+ 	public void ResetSwapChain();
+ 	public void RequestActivation();
+ 	TypedEventHandler<StereoHeadMountedDisplay, object> SwapChainResized;
+ 	TypedEventHandler<StereoHeadMountedDisplay, object> SwapChainResizing;
+ 	TypedEventHandler<IPositionalLocator, object> StateChanged;
+ }

+ public struct Windows.Graphics.Display.StereoViewProjection {
+ 	public ViewProjection Left;
+ 	public ViewProjection Right;
+ }

+ public struct Windows.Graphics.Display.ViewProjection {
+ 	public Matrix4x4 View;
+ 	public Matrix4x4 Projection;
+ }

+ public class Windows.Graphics.Face.DetectedFace {
+ 	public BitmapBounds FaceBox { get; }
+ 	public DetectedFace();
+ }

+ public class Windows.Graphics.Face.FaceDetector {
+ 	public FaceSize MinimumDetectableFaceSize { get; set; }
+ 	public FaceSize MaximumDetectableFaceSize { get; set; }
+ 	public FaceDetector();
+ 	public IAsyncOperation<IVectorView<DetectedFace>> DetectFacesAsync( SoftwareBitmap returnValue );
+ 	public IAsyncOperation<IVectorView<DetectedFace>> DetectFacesWithSearchAreaAsync( SoftwareBitmap returnValue, BitmapBounds image );
+ }

+ public enum Windows.Graphics.Face.FaceFeature {
+ 	LeftEye = 0,
+ 	RightEye = 1,
+ 	Nose = 2,
+ 	MouthLeftCorner = 3,
+ 	MouthRightCorner = 4,
+ 	LeftEyebrowTopLeft = 5,
+ 	LeftEyebrowTopRight = 6,
+ 	LeftEyeOuterCorner = 7,
+ 	TopLeftEyelidMiddle = 8,
+ 	BottomLeftEyelidMiddle = 9,
+ 	LeftEyeInnerCorner = 10,
+ 	RightEyebrowTopLeft = 11,
+ 	RightEyebrowTopRight = 12,
+ 	RightEyeInnerCorner = 13,
+ 	TopRightEyelidMiddle = 14,
+ 	BottomRightEyelidMiddle = 15,
+ 	RightEyeOuterCorner = 16,
+ 	NoseLeftBridge = 17,
+ 	NoseRightBridge = 18,
+ 	NoseLeftWingTop = 19,
+ 	NoseRightWingTop = 20,
+ 	NoseLeftWingSideTop = 21,
+ 	NoseRightWingSideTop = 22,
+ 	UpperLipBottomVDip = 23,
+ 	UpperLipBottomMiddle = 24,
+ 	LowerLipTopMiddle = 25,
+ 	LowerLipBottom = 26,
+ }

+ public class Windows.Graphics.Face.FacePoints {
+ 	public FacePoints();
+ 	public BitmapBounds ComputeFaceBox();
+ 	public IAsyncOperation<FacePoints> TrackAsync( SoftwareBitmap returnValue );
+ }

+ public struct Windows.Graphics.Face.FaceSize {
+ 	public uint Width;
+ 	public uint Height;
+ }

+ public class Windows.Graphics.Face.FaceTracker {
+ 	public FaceSize MinimumDetectableFaceSize { get; set; }
+ 	public FaceSize MaximumDetectableFaceSize { get; set; }
+ 	public FaceTracker();
+ 	public IAsyncOperation<IVectorView<DetectedFace>> ProcessNextFrameAsync( VideoFrame returnValue );
+ }


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

 new file: new\Windows.Human.winmd
 old file: old\Windows.Human.winmd (NOT EXISTS!)

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

+ public class Windows.Human.Person {
+ 	public Pose GetPredictedPoseForCurrentFrame();
+ 	public void ReorientToHead( Pose pose, ref Pose reoriented );
+ 	public IAsyncOperation<Pose> LocateAsync();
+ 	TypedEventHandler<Person, FingerPressedEventArgs> FingerPressed;
+ 	TypedEventHandler<Person, FingerReleasedEventArgs> FingerReleased;
+ 	TypedEventHandler<Person, HandDetectedEventArgs> HandDetected;
+ 	TypedEventHandler<Person, HandLostEventArgs> HandLost;
+ 	TypedEventHandler<Person, HandMovedEventArgs> HandMoved;
+ 	TypedEventHandler<Person, SelectDetectedEventArgs> SelectDetected;
+ }

+ public class Windows.Human.Pose {
+ 	public Matrix4x4 CameraToPoseTransform { get; }
+ 	public Ray GazeDirection { get; }
+ 	public IVectorView<Hand> Hands { get; }
+ 	public Matrix4x4 HeadToPoseTransform { get; }
+ 	public Matrix4x4 LeftEarToPoseTransform { get; }
+ 	public Matrix4x4 RightEarToPoseTransform { get; }
+ 	public Locatability Locatability { get; }
+ 	public Pose GetUpdatedPrediction();
+ 	public Pose GetInterpolation( TimeSpan value );
+ 	public Locatability TryGetRelativeTransformTo( ILocatable locatability, ref Matrix4x4 pTarget );
+ 	public static TimeSpan GetTimeSpanBetweenPoses( Pose timeSpan, Pose from );
+ }

+ public class Windows.Human.Gestures.GestureRecognizer {
+ 	public NuiGestureSettings GestureSettings { get; set; }
+ 	public bool IsActive { get; }
+ 	public GestureRecognizer();
+ 	public void ProcessFingerPressedEvent( FingerPressedEventArgs value );
+ 	public void ProcessFingerReleasedEvent( FingerReleasedEventArgs value );
+ 	public void ProcessHandMovedEvent( HandMovedEventArgs value );
+ 	public void ProcessHandDetectedEvent( HandDetectedEventArgs value );
+ 	public void ProcessHandLostEvent( HandLostEventArgs value );
+ 	public void CompleteGesture();
+ 	TypedEventHandler<GestureRecognizer, ScrollCanceledEventArgs> ScrollCanceled;
+ 	TypedEventHandler<GestureRecognizer, ScrollCompletedEventArgs> ScrollCompleted;
+ 	TypedEventHandler<GestureRecognizer, ScrollStartedEventArgs> ScrollStarted;
+ 	TypedEventHandler<GestureRecognizer, ScrollUpdatedEventArgs> ScrollUpdated;
+ 	TypedEventHandler<GestureRecognizer, SelectDetectedEventArgs> SelectDetected;
+ 	TypedEventHandler<GestureRecognizer, ZoomCanceledEventArgs> ZoomCanceled;
+ 	TypedEventHandler<GestureRecognizer, ZoomCompletedEventArgs> ZoomCompleted;
+ 	TypedEventHandler<GestureRecognizer, ZoomStartedEventArgs> ZoomStarted;
+ 	TypedEventHandler<GestureRecognizer, ZoomUpdatedEventArgs> ZoomUpdated;
+ }

+ public enum Windows.Human.Gestures.GestureSource {
+ 	None = 0,
+ 	Hand = 1,
+ 	Speech = 2,
+ }

+ public interface Windows.Human.Gestures.IGestureEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ }

+ public interface Windows.Human.Gestures.IScrollEventArgs {
+ 	public Vector2 NormalizedVelocity { get; }
+ }

+ public interface Windows.Human.Gestures.IZoomEventArgs {
+ 	public float NormalizedVelocity { get; }
+ }

+ public enum Windows.Human.Gestures.NuiGestureSettings {
+ 	None = 0,
+ 	Select = 1,
+ 	ScrollX = 2,
+ 	ScrollY = 4,
+ 	ScrollRailsX = 8,
+ 	ScrollRailsY = 16,
+ 	Zoom = 32,
+ 	ZoomRails = 64,
+ }

+ public class Windows.Human.Gestures.ScrollCanceledEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public Vector2 NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Gestures.ScrollCompletedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public Vector2 NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Gestures.ScrollStartedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public Vector2 NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Gestures.ScrollUpdatedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public Vector2 NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Gestures.SelectDetectedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ }

+ public class Windows.Human.Gestures.ZoomCanceledEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public float NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Gestures.ZoomCompletedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public float NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Gestures.ZoomStartedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public float NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Gestures.ZoomUpdatedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ 	public GestureSource Source { get; }
+ 	public float NormalizedVelocity { get; }
+ }

+ public class Windows.Human.Hands.FingerPressedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ }

+ public class Windows.Human.Hands.FingerReleasedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ }

+ public class Windows.Human.Hands.Hand {
+ 	public Vector3 GuidanceDirection { get; }
+ 	public float GuidanceScore { get; }
+ 	public uint Id { get; }
+ 	public Vector3 Position { get; }
+ 	public HandState State { get; }
+ }

+ public class Windows.Human.Hands.HandDetectedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ }

+ public class Windows.Human.Hands.HandLostEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ }

+ public class Windows.Human.Hands.HandMovedEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ }

+ public enum Windows.Human.Hands.HandState {
+ 	Released = 0,
+ 	Holding = 1,
+ }

+ public interface Windows.Human.Hands.IHandEventArgs {
+ 	public Hand Hand { get; }
+ 	public Pose Pose { get; }
+ }


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

 new file: new\Windows.Management.winmd
 old file: old\Windows.Management.winmd

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

+ public class Windows.Management.Orchestration.Core.OrchestrationResult {
+ 	public uint ExtendedErrorCode { get; }
+ 	public OrchestrationStatus Status { get; }
+ }

+ public class Windows.Management.Orchestration.Core.OrchestrationSession {
+ 	public bool InSession { get; }
+ 	public static OrchestrationResult Start();
+ 	public static IAsyncAction StopAsync();
+ 	public static IAsyncOperation<OrchestrationResult> LaunchExeAsync( string result, string exeFullPath );
+ 	public static IAsyncOperation<OrchestrationResult> SetAllowedAppsAsync( IIterable<string> result );
+ 	public static IAsyncOperation<OrchestrationResult> SetAllowedExesAsync( IIterable<string> result );
+ 	public static IAsyncOperation<UriRestrictionResult> SetAllowedUrisAsync( IIterable<Uri> result );
+ 	public static IAsyncOperation<OrchestrationResult> AllowAllAppsAsync();
+ 	public static IAsyncOperation<OrchestrationResult> AllowAllExesAsync();
+ 	public static IAsyncOperation<OrchestrationResult> AllowAllUrisAsync();
+ }

+ public enum Windows.Management.Orchestration.Core.OrchestrationStatus {
+ 	Success = 0,
+ 	ExtendedError = 1,
+ 	ErrorAccessDeniedByPolicy = 2,
+ 	ErrorSessionAlreadyStarted = 3,
+ 	ErrorSessionStopped = 4,
+ }

+ public class Windows.Management.Orchestration.Core.UriRestrictionResult {
+ 	public uint ExtendedErrorCode { get; }
+ 	public Uri FailedUri { get; }
+ 	public OrchestrationStatus Status { get; }
+ }

+ public struct Windows.Management.Workplace.WorkplaceSettingsContract {
+ }


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

 new file: new\Windows.Media.winmd
 old file: old\Windows.Media.winmd

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

+ public struct Windows.Media.MediaControlContract {
+ }

| public class Windows.Media.Audio.AudioFileOutputNode {
+ 	public MediaEncodingProfile FileEncodingProfile { get; }
- 	public AudioEncodingProperties FileFormat { get; }
| }

| public class Windows.Media.Audio.AudioGraph {
+ 	public IAsyncOperation<CreateAudioFileOutputNodeResult> CreateFileOutputNodeAsync( IStorageFile result, MediaEncodingProfile file );
+ 	public static IAsyncOperation<CreateAudioGraphResult> CreateAsync();
+ 	public static IAsyncOperation<CreateAudioGraphResult> CreateAsync( AudioGraphSettings result );
- 	public AudioGraph( int samplesPerQuantum, AudioEncodingProperties encodingProperties );
| }

+ public enum Windows.Media.Audio.AudioGraphCreationStatus {
+ 	Success = 0,
+ 	DeviceNotAvailable = 1,
+ 	FormatNotSupported = 2,
+ 	UnknownFailure = 3,
+ }

+ public class Windows.Media.Audio.AudioGraphSettings {
+ 	public QuantumSizeSelectionMode QuantumSizeSelectionMode { get; set; }
+ 	public DeviceInformation MasterDevice { get; set; }
+ 	public AudioEncodingProperties Format { get; set; }
+ 	public int DesiredSamplesPerQuantum { get; set; }
+ }

+ public enum Windows.Media.Audio.AudioGraphUnrecoverableError {
+ 	None = 0,
+ 	AudioDeviceLost = 1,
+ 	AudioSessionDisconnected = 2,
+ 	UnknownFailure = 3,
+ }

+ public class Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs {
+ 	public AudioGraphUnrecoverableError Error { get; }
+ }

+ public class Windows.Media.Audio.CreateAudioGraphResult {
+ 	public AudioGraph Graph { get; }
+ 	public AudioGraphCreationStatus Status { get; }
+ }

+ public enum Windows.Media.Audio.QuantumSizeSelectionMode {
+ 	SystemDefault = 0,
+ 	LowLatency = 1,
+ 	ClosestToDesired = 2,
+ }

+ public struct Windows.Media.Capture.CameraCaptureUIContract {
+ }

| public enum Windows.Media.Capture.MediaCategory {
+ 	Media = 2,
+ 	GameChat = 3,
+ 	Speech = 4,
| }

+ public class Windows.Media.Casting.CastingConnection {
+ 	public CastingSource Source { get; set; }
+ 	public CastingDevice Device { get; }
+ 	public CastingConnectionState State { get; }
+ 	public IAsyncOperation<CastingConnectionErrorStatus> DisconnectAsync();
+ 	public void Close();
+ 	TypedEventHandler<CastingConnection, CastingConnectionErrorOccurredEventArgs> ErrorOccurred;
+ 	TypedEventHandler<CastingConnection, object> StateChanged;
+ }

+ public class Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs {
+ 	public CastingConnectionErrorStatus ErrorStatus { get; }
+ 	public string Message { get; }
+ }

+ public enum Windows.Media.Casting.CastingConnectionErrorStatus {
+ 	Succeeded = 0,
+ 	DeviceDidNotRespond = 1,
+ 	DeviceError = 2,
+ 	DeviceLocked = 3,
+ 	ProtectedPlaybackFailed = 4,
+ 	InvalidCastingSource = 5,
+ 	Unknown = 6,
+ }

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

+ public class Windows.Media.Casting.CastingDevice {
+ 	public string FriendlyName { get; }
+ 	public IRandomAccessStreamWithContentType Icon { get; }
+ 	public string Id { get; }
+ 	public CastingPlaybackTypes SupportedCastingPlaybackTypes { get; }
+ 	public IAsyncOperation<StartCastingResult> RequestStartCastingAsync( CastingSource operation );
+ }

+ public enum Windows.Media.Casting.CastingPlaybackTypes {
+ 	None = 0,
+ 	Audio = 1,
+ 	Video = 2,
+ 	Picture = 4,
+ }

+ public class Windows.Media.Casting.CastingSource {
+ 	public Uri PreferredSourceUri { get; set; }
+ }

+ public interface Windows.Media.Casting.ICastingConnection {
+ 	public CastingDevice Device { get; }
+ 	public CastingSource Source { get; set; }
+ 	public CastingConnectionState State { get; }
+ 	public IAsyncOperation<CastingConnectionErrorStatus> DisconnectAsync();
+ 	TypedEventHandler<CastingConnection, CastingConnectionErrorOccurredEventArgs> ErrorOccurred;
+ 	TypedEventHandler<CastingConnection, object> StateChanged;
+ }

+ public class Windows.Media.Casting.StartCastingResult {
+ 	public CastingConnection Connection { get; }
+ 	public CastingConnectionErrorStatus Status { get; }
+ }

+ public enum Windows.Media.ClosedCaptioning.ClosedCaptionColor {
+ 	Default = 0,
+ 	White = 1,
+ 	Black = 2,
+ 	Red = 3,
+ 	Green = 4,
+ 	Blue = 5,
+ 	Yellow = 6,
+ 	Magenta = 7,
+ 	Cyan = 8,
+ }

+ public enum Windows.Media.ClosedCaptioning.ClosedCaptionEdgeEffect {
+ 	Default = 0,
+ 	None = 1,
+ 	Raised = 2,
+ 	Depressed = 3,
+ 	Uniform = 4,
+ 	DropShadow = 5,
+ }

+ public enum Windows.Media.ClosedCaptioning.ClosedCaptionOpacity {
+ 	Default = 0,
+ 	OneHundredPercent = 1,
+ 	SeventyFivePercent = 2,
+ 	TwentyFivePercent = 3,
+ 	ZeroPercent = 4,
+ }

+ public class Windows.Media.ClosedCaptioning.ClosedCaptionProperties {
+ 	public ClosedCaptionColor BackgroundColor { get; }
+ 	public ClosedCaptionOpacity BackgroundOpacity { get; }
+ 	public Color ComputedBackgroundColor { get; }
+ 	public Color ComputedFontColor { get; }
+ 	public Color ComputedRegionColor { get; }
+ 	public ClosedCaptionColor FontColor { get; }
+ 	public ClosedCaptionEdgeEffect FontEffect { get; }
+ 	public ClosedCaptionOpacity FontOpacity { get; }
+ 	public ClosedCaptionSize FontSize { get; }
+ 	public ClosedCaptionStyle FontStyle { get; }
+ 	public ClosedCaptionColor RegionColor { get; }
+ 	public ClosedCaptionOpacity RegionOpacity { get; }
+ }

+ public enum Windows.Media.ClosedCaptioning.ClosedCaptionSize {
+ 	Default = 0,
+ 	FiftyPercent = 1,
+ 	OneHundredPercent = 2,
+ 	OneHundredFiftyPercent = 3,
+ 	TwoHundredPercent = 4,
+ }

+ public enum Windows.Media.ClosedCaptioning.ClosedCaptionStyle {
+ 	Default = 0,
+ 	MonospacedWithSerifs = 1,
+ 	ProportionalWithSerifs = 2,
+ 	MonospacedWithoutSerifs = 3,
+ 	ProportionalWithoutSerifs = 4,
+ 	Casual = 5,
+ 	Cursive = 6,
+ 	SmallCapitals = 7,
+ }

- public enum Windows.Media.ClosedCaptions.ClosedCaptionColor;

- public enum Windows.Media.ClosedCaptions.ClosedCaptionEdgeEffect;

- public enum Windows.Media.ClosedCaptions.ClosedCaptionOpacity;

- public class Windows.Media.ClosedCaptions.ClosedCaptionProperties;

- public enum Windows.Media.ClosedCaptions.ClosedCaptionSize;

- public enum Windows.Media.ClosedCaptions.ClosedCaptionStyle;

- public void delegate Windows.Media.Core.AssetResolvedEventHandler( MediaAsset sender );

- public class Windows.Media.Core.MediaAsset;

+ public class Windows.Media.Core.MediaSource {
+ 	public ValueSet CustomProperties { get; }
+ 	public IReference<TimeSpan> Duration { get; }
+ 	public bool IsResolved { get; }
+ 	public static MediaSource CreateFromAdaptiveMediaSource( AdaptiveMediaSource value );
+ 	public static MediaSource CreateFromMediaStreamSource( MediaStreamSource value );
+ 	public static MediaSource CreateFromMseStreamSource( MseStreamSource value );
+ 	public static MediaSource CreateFromInterface( IMediaSource value );
+ 	public static MediaSource CreateFromStorageFile( IStorageFile value );
+ 	public static MediaSource CreateFromStream( IRandomAccessStream value, string stream );
+ 	public static MediaSource CreateFromStreamReference( IRandomAccessStreamReference value, string stream );
+ 	public static MediaSource CreateFromUri( Uri value );
+ 	Windows.Media.Core.MediaSourceResolvedEventHandler SourceResolved;
+ }

+ public void delegate Windows.Media.Core.MediaSourceResolvedEventHandler( MediaSource sender );

+ public struct Windows.Media.Devices.CallControlContract {
+ }

+ public enum Windows.Media.Devices.MediaCaptureOptimization {
+ 	Default = 0,
+ 	Quality = 1,
+ 	Latency = 2,
+ 	Power = 3,
+ 	LatencyThenQuality = 4,
+ 	LatencyThenPower = 5,
+ 	PowerAndQuality = 6,
+ }

- public enum Windows.Media.Devices.MediaCaptureOptimizations;

| public class Windows.Media.Devices.VideoDeviceController {
+ 	public MediaCaptureOptimization DesiredOptimization { get; set; }
- 	public MediaCaptureOptimizations DesiredOptimizations { get; set; }
| }

+ public class Windows.Media.DialProtocol.DialApp {
+ 	public string AppName { get; }
+ 	public IAsyncOperation<DialAppLaunchResult> RequestLaunchAsync( string value );
+ 	public IAsyncOperation<DialAppStopResult> StopAsync();
+ 	public IAsyncOperation<DialAppStateDetails> GetAppStateAsync();
+ }

+ public enum Windows.Media.DialProtocol.DialAppLaunchResult {
+ 	Launched = 0,
+ 	FailedToLaunch = 1,
+ 	NotFound = 2,
+ 	NetworkFailure = 3,
+ }

+ public enum Windows.Media.DialProtocol.DialAppState {
+ 	Unknown = 0,
+ 	Stopped = 1,
+ 	Running = 2,
+ 	NetworkFailure = 3,
+ }

+ public class Windows.Media.DialProtocol.DialAppStateDetails {
+ 	public string FullXml { get; }
+ 	public DialAppState State { get; }
+ }

+ public enum Windows.Media.DialProtocol.DialAppStopResult {
+ 	Stopped = 0,
+ 	StopFailed = 1,
+ 	OperationNotSupported = 2,
+ 	NetworkFailure = 3,
+ }

+ public class Windows.Media.DialProtocol.DialDevice {
+ 	public string Id { get; }
+ 	public DialApp GetDialApp( string value );
+ }

+ public interface Windows.Media.DialProtocol.IDialDeviceStatics {
+ 	public string GetDeviceSelector( string selector );
+ 	public IAsyncOperation<DialDevice> FromIdAsync( string operation );
+ 	public IAsyncOperation<bool> DeviceInfoSupportsDialAsync( DeviceInformation operation );
+ }

| public class Windows.Media.Editing.MediaOverlay {
+ 	public bool AudioEnabled { get; set; }
| }

+ public struct Windows.Media.PlayTo.DlnaContract {
+ }

+ public struct Windows.Media.PlayTo.PlayToContract {
+ }

+ public class Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs {
+ 	public MediaPlaybackItem NewItem { get; }
+ 	public MediaPlaybackItem OldItem { get; }
+ }

| public enum Windows.Media.Playback.FailedMediaStreamKind {
* 	Audio = 1,
* 	Video = 2,
| }

+ public interface Windows.Media.Playback.IMediaPlaybackSource {
+ }

+ public class Windows.Media.Playback.MediaPlaybackItem {
+ 	public MediaSource Source { get; }
+ 	public MediaPlaybackItem( MediaSource source );
+ }

+ public class Windows.Media.Playback.MediaPlaybackItemError {
+ 	public MediaPlaybackItemErrorCode ErrorCode { get; }
+ 	public void Propagate();
+ }

+ public enum Windows.Media.Playback.MediaPlaybackItemErrorCode {
+ 	None = 0,
+ 	Aborted = 1,
+ 	NetworkError = 2,
+ 	DecodeError = 3,
+ 	SourceNotSupportedError = 4,
+ 	EncryptionError = 5,
+ }

+ public class Windows.Media.Playback.MediaPlaybackItemFailedEventArgs {
+ 	public MediaPlaybackItemError Error { get; }
+ 	public MediaPlaybackItem Item { get; }
+ }

+ public class Windows.Media.Playback.MediaPlaybackItemResolvedEventArgs {
+ 	public MediaPlaybackItem Item { get; }
+ }

+ public class Windows.Media.Playback.MediaPlaybackList {
+ 	public bool IsShuffled { get; set; }
+ 	public bool IsLooping { get; set; }
+ 	public MediaPlaybackItem CurrentItem { get; }
+ 	public IObservableVector<MediaPlaybackItem> Items { get; }
+ 	public MediaPlaybackList( Playlist playlist );
+ 	public MediaPlaybackList();
+ 	public MediaPlaybackItem SwitchToNextItem();
+ 	public MediaPlaybackItem SwitchToPreviousItem();
+ 	public MediaPlaybackItem SwitchToItemAtIndex( uint item );
+ 	TypedEventHandler<MediaPlaybackList, CurrentMediaPlaybackItemChangedEventArgs> CurrentItemChanged;
+ 	TypedEventHandler<MediaPlaybackList, MediaPlaybackItemFailedEventArgs> ItemErrorOccurred;
+ 	TypedEventHandler<MediaPlaybackList, MediaPlaybackItemResolvedEventArgs> ItemResolved;
+ }

- public class Windows.Media.Playback.PlayableMediaClip;

- public class Windows.Media.Playback.PlayableMediaClipError;

- public enum Windows.Media.Playback.PlayableMediaClipErrorCode;

| public class Windows.Media.Playback.PlaybackMediaMarker {
+ 	public PlaybackMediaMarker( TimeSpan value );
+ 	public PlaybackMediaMarker( TimeSpan value, string mediaMarketType, string text );
| }

- public class Windows.Media.Playlists.ClipFailedEventArgs;

- public class Windows.Media.Playlists.ClipResolvedEventArgs;

- public class Windows.Media.Playlists.CurrentClipChangedEventArgs;

- public class Windows.Media.Playlists.PlaylistMediaSource;

| public class Windows.Media.Protection.MediaProtectionPMPServer {
+ 	public MediaProtectionPMPServer( IPropertySet pProperties );
- 	public static MediaProtectionPMPServer CreatePMPServer( IPropertySet ppObject );
| }

| public enum Windows.Media.Render.AudioRenderCategory {
+ 	Movie = 1,
+ 	Media = 2,
+ 	GameChat = 8,
+ 	Speech = 9,
| }

+ public class Windows.Media.SpeechRecognition.VoiceCommandManager {
+ 	public IMapView<string, VoiceCommandSet> InstalledCommandSets { get; }
+ 	public static IAsyncAction InstallCommandSetsFromStorageFileAsync( StorageFile installAction );
+ }

+ public class Windows.Media.SpeechRecognition.VoiceCommandSet {
+ 	public string Language { get; }
+ 	public string Name { get; }
+ 	public IAsyncAction SetPhraseListAsync( string updateAction, IIterable<string> phraseListName );
+ }


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

 new file: new\Windows.Networking.winmd
 old file: old\Windows.Networking.winmd

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

+ public class Windows.Networking.Connectivity.AttributedNetworkUsage {
+ 	public string AttributionId { get; }
+ 	public string AttributionName { get; }
+ 	public IRandomAccessStreamReference AttributionThumbnail { get; }
+ 	public ulong BytesReceived { get; }
+ 	public ulong BytesSent { get; }
+ }

| public class Windows.Networking.Connectivity.ConnectionProfile {
+ 	public IAsyncOperation<IVectorView<AttributedNetworkUsage>> GetAttributedNetworkUsageAsync( DateTime value, DateTime startTime, NetworkUsageStates endTime );
| }

+ public struct Windows.Networking.Connectivity.WwanContract {
+ }

+ public struct Windows.Networking.NetworkOperators.NetworkOperatorsTetheringContract {
+ }

| public class Windows.Networking.Proximity.PeerInformation {
+ 	public HostName HostName { get; }
+ 	public string ServiceName { get; }
| }

| public class Windows.Networking.Sockets.DatagramSocketControl {
+ 	public bool MulticastOnly { get; set; }
| }

| public class Windows.Networking.Sockets.SocketActivityContext {
+ 	public SocketActivityContext();
| }

| public class Windows.Networking.Vpn.VpnManagementAgent {
+ 	public IAsyncOperation<VpnManagementErrorStatus> AddProfileFromObjectAsync( IVpnProfile operation );
+ 	public IAsyncOperation<VpnManagementErrorStatus> UpdateProfileFromObjectAsync( IVpnProfile operation );
+ 	public IAsyncOperation<VpnManagementErrorStatus> DeleteProfileAsync( IVpnProfile operation );
+ 	public IAsyncOperation<VpnManagementErrorStatus> ConnectProfileAsync( IVpnProfile operation );
+ 	public IAsyncOperation<VpnManagementErrorStatus> ConnectProfileWithPasswordCredentialAsync( IVpnProfile operation, PasswordCredential profile );
+ 	public IAsyncOperation<VpnManagementErrorStatus> DisconnectProfileAsync( IVpnProfile operation );
| }


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

 new file: new\Windows.Phone.winmd
 old file: old\Windows.Phone.winmd (NOT EXISTS!)

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

+ public interface Windows.Phone.ApplicationModel.IPackageIdWithMetadata {
+ 	public string Author { get; }
+ 	public string ProductId { get; }
+ }

+ public interface Windows.Phone.ApplicationModel.IPackageWithMetadata {
+ 	public DateTime InstallDate { get; }
+ 	public string GetThumbnailToken();
+ 	public void Launch( string parameters );
+ }

+ public enum Windows.Phone.UI.Core.CoreInputScope {
+ 	Default = 0,
+ 	Url = 1,
+ 	EmailSmtpAddress = 5,
+ 	Number = 29,
+ 	TelephoneNumber = 32,
+ 	Text = 49,
+ 	Search = 51,
+ }

+ public class Windows.Phone.UI.Core.CoreSelectionChangedEventArgs {
+ 	public uint Length { get; }
+ 	public uint Start { get; }
+ }

+ public class Windows.Phone.UI.Core.CoreTextChangedEventArgs {
+ 	public string NewText { get; }
+ 	public uint OldLength { get; }
+ 	public uint Start { get; }
+ }

+ public interface Windows.Phone.UI.Core.ICoreWindowKeyboardInput {
+ 	public bool IsKeyboardInputEnabled { get; set; }
+ 	public KeyboardInputBuffer KeyboardInputBuffer { get; set; }
+ }

+ public class Windows.Phone.UI.Core.KeyboardInputBuffer {
+ 	public string Text { get; set; }
+ 	public CoreInputScope InputScope { get; set; }
+ 	public uint SelectionLength { get; }
+ 	public uint SelectionStart { get; }
+ 	public KeyboardInputBuffer();
+ 	public void Select( uint start, uint length );
+ 	public void SelectFromTap( uint characterIndex );
+ 	TypedEventHandler<KeyboardInputBuffer, CoreSelectionChangedEventArgs> SelectionChanged;
+ 	TypedEventHandler<KeyboardInputBuffer, CoreTextChangedEventArgs> TextChanged;
+ }


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

 new file: new\Windows.Security.winmd
 old file: old\Windows.Security.winmd

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

| public class Windows.Security.Authentication.OnlineId.OnlineIdAuthenticator {
+ 	public string AccountId { get; set; }
| }

| public class Windows.Security.Authentication.Web.WebAuthenticationBroker {
+ 	public static void AuthenticateAndContinue( Uri requestUri );
+ 	public static void AuthenticateAndContinue( Uri requestUri, Uri callbackUri );
+ 	public static void AuthenticateAndContinue( Uri requestUri, Uri callbackUri, ValueSet continuationData, WebAuthenticationOptions options );
+ 	public static IAsyncOperation<WebAuthenticationResult> AuthenticateSilentlyAsync( Uri asyncInfo );
+ 	public static IAsyncOperation<WebAuthenticationResult> AuthenticateSilentlyAsync( Uri asyncInfo, WebAuthenticationOptions requestUri );
| }

- public class Windows.Security.Authentication.Web.Core.WebAccountChangedEventArgs;

- public class Windows.Security.Authentication.Web.Core.WebAccountDeletedEventArgs;

| public class Windows.Security.Authentication.Web.Core.WebAuthenticationCoreManager {
+ 	public static IAsyncOperation<WebTokenRequestResult> RequestTokenAsync( WebTokenRequest asyncInfo );
+ 	public static IAsyncOperation<WebTokenRequestResult> RequestTokenAsync( WebTokenRequest asyncInfo, WebAccount request );
+ 	public static IAsyncOperation<WebTokenRequestResult> RequestTokenWithHintsAsync( WebTokenRequest asyncInfo, IVectorView<WebAccount> request );
+ 	public static IAsyncOperation<WebAccount> FindAccountAsync( WebAccountProvider asyncInfo, string provider );
+ 	public static IAsyncOperation<WebAccountProvider> FindAccountProviderAsync( string asyncInfo );
+ 	public static IAsyncOperation<WebAccountProvider> FindAccountProviderWithAuthorityAsync( string asyncInfo, string webAccountProviderId );
- 	public static IAsyncOperation<IVectorView<WebAccount>> FindAllAccountsAsync();
- 	public static IAsyncAction ForgetAccountAsync( WebAccount asyncInfo );
| }

+ public class Windows.Security.Authentication.Web.Core.WebProviderError {
+ 	public uint ErrorCode { get; }
+ 	public string ErrorMessage { get; }
+ 	public WebProviderError( uint errorCode, string errorMessage );
+ }

- public class Windows.Security.Authentication.Web.Core.WebTokenError;

| public class Windows.Security.Authentication.Web.Core.WebTokenRequest {
+ 	public WebAccountProvider WebAccountProvider { get; }
- 	public string WebAccountProviderId { get; }
+ 	public WebTokenRequest( WebAccountProvider provider, string scope, string clientId );
+ 	public WebTokenRequest( WebAccountProvider provider, string scope, string clientId, WebTokenRequestPromptType promptType );
| }

| public class Windows.Security.Authentication.Web.Core.WebTokenRequestResult {
* 	public WebProviderError ResponseError { get; }
| }

| public class Windows.Security.Authentication.Web.Core.WebTokenResponse {
* 	public WebProviderError ProviderError { get; }
+ 	public WebTokenResponse( string token, WebAccount webAccount, WebProviderError error );
| }

| public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation {
+ 	public void ReportError( WebProviderError value );
| }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderDeleteAccountOperation {
+ 	public WebAccount WebAccount { get; }
+ 	public WebAccountProviderOperationKind Kind { get; }
+ 	public void ReportCompleted();
+ 	public void ReportError( WebProviderError value );
+ }

| public class Windows.Security.Authentication.Web.Provider.WebAccountProviderGetTokenSilentOperation {
+ 	public void ReportError( WebProviderError value );
| }

| public enum Windows.Security.Authentication.Web.Provider.WebAccountProviderOperationKind {
+ 	DeleteAccount = 4,
* 	RetrieveCookies = 5,
| }

| public class Windows.Security.Authentication.Web.Provider.WebAccountProviderRequestTokenOperation {
+ 	public void ReportError( WebProviderError value );
| }

| public class Windows.Security.Authentication.Web.Provider.WebAccountProviderRetrieveCookiesOperation {
+ 	public void ReportError( WebProviderError value );
| }

+ public enum Windows.Security.Authentication.Web.Provider.WebAccountSelectionOptions {
+ 	Default = 0,
+ 	AddNew = 1,
+ }

| public class Windows.Security.Authentication.Web.Provider.WebProviderTokenRequest {
+ 	public WebAccountSelectionOptions WebAccountSelectionOptions { get; }
| }

+ public class Windows.Security.Credentials.KeyCredential {
+ 	public string Id { get; }
+ 	public CryptographicKey Key { get; }
+ }

+ public class Windows.Security.Credentials.KeyCredentialManager {
+ 	public static IAsyncOperation<KeyCredentialRequestResult> RequestCreateAsync( string operation, bool id );
+ 	public static IAsyncOperation<KeyCredentialRequestResult> OpenAsync( string operation );
+ 	public static IAsyncAction DeleteAsync( string value );
+ }

+ public class Windows.Security.Credentials.KeyCredentialRequestResult {
+ 	public KeyCredential KeyCredential { get; }
+ 	public KeyCredentialStatus Status { get; }
+ }

+ public enum Windows.Security.Credentials.KeyCredentialStatus {
+ 	Success = 0,
+ 	UnknownError = 1,
+ 	NotFound = 2,
+ 	UserCanceled = 3,
+ 	CredentialExists = 4,
+ 	SecurityDeviceLocked = 5,
+ 	AccountNotConnected = 6,
+ }

| public class Windows.Security.Credentials.WebAccountProvider {
+ 	public string Authority { get; }
| }

| public enum Windows.Security.EnterpriseData.FileProtectionStatus {
- 	Undetermined = 0,
- 	Unknown = 0,
- 	ProtectedByOtherUser = 4,
- 	ProtectedToOtherEnterprise = 5,
- 	ProtectedToOtherIdentity = 7,
| }

+ public struct Windows.Security.EnterpriseData.FileRevocationContract {
+ }

| public class Windows.Security.EnterpriseData.FileRevocationManager {
+ 	public static IAsyncOperation<FileProtectionStatus> ProtectAsync( IStorageItem result, string storageItem );
+ 	public static IAsyncOperation<bool> CopyProtectionAsync( IStorageItem result, IStorageItem sourceStorageItem );
+ 	public static IAsyncOperation<FileProtectionStatus> GetStatusAsync( IStorageItem result );
| }

| public class Windows.Security.EnterpriseData.ProtectionPolicyManager {
+ 	public static ThreadNetworkContext CreateCurrentThreadNetworkContext( string result );
+ 	public static IAsyncOperation<string> GetPrimaryManagedIdentityForNetworkEndpointAsync( HostName result );
- 	public static bool TrySetCurrentThreadNetworkContext( string result );
- 	public static void ClearCurrentThreadNetworkContext();
- 	public static string GetPrimaryManagedIdentityForNetworkEndpoint( HostName primaryManagedIdentity );
| }

+ public class Windows.Security.EnterpriseData.ThreadNetworkContext {
+ 	public void Close();
+ }

+ public struct Windows.Security.ExchangeActiveSyncProvisioning.EasContract {
+ }

- public class Windows.Security.NextGenerationCredential.UserIdKeyProvider;


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

 new file: new\Windows.Services.winmd
 old file: old\Windows.Services.winmd

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

 found no differences.

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

 new file: new\Windows.Storage.winmd
 old file: old\Windows.Storage.winmd

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

| public class Windows.Storage.ApplicationData {
+ 	public StorageFolder GetPublisherCacheFolder( string value );
+ 	public IAsyncAction ClearPublisherCacheFolderAsync( string clearOperation );
- 	public StorageFolder GetPublisherFolderFolder( string value );
- 	public IAsyncAction ClearPublisherFolderAsync( string clearOperation );
| }

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

+ public interface Windows.Storage.IStorageFile2 {
+ 	public IAsyncOperation<IRandomAccessStream> OpenAsync( FileAccessMode operation, StorageOpenOptions accessMode );
+ 	public IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync( StorageOpenOptions operation );
+ }

| public class Windows.Storage.StorageFile {
+ 	public IAsyncOperation<IRandomAccessStream> OpenAsync( FileAccessMode operation, StorageOpenOptions accessMode );
+ 	public IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync( StorageOpenOptions operation );
| }

+ public enum Windows.Storage.StorageOpenOptions {
+ 	None = 0,
+ 	AllowOnlyReaders = 1,
+ }

+ public struct Windows.Storage.BulkAccess.BulkAccessContract {
+ }

| public class Windows.Storage.BulkAccess.FileInformation {
+ 	public IAsyncOperation<IRandomAccessStream> OpenAsync( FileAccessMode operation, StorageOpenOptions accessMode );
+ 	public IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync( StorageOpenOptions operation );
| }

+ public class Windows.Storage.FileProperties.GeotagHelper {
+ 	public static IAsyncOperation<Geopoint> GetGeotagAsync( IStorageFile operation );
+ 	public static IAsyncAction SetGeotagFromGeolocatorAsync( IStorageFile operation, Geolocator file );
+ 	public static IAsyncAction SetGeotagAsync( IStorageFile operation, Geopoint file );
+ }

| public class Windows.Storage.Pickers.FileOpenPicker {
+ 	public ValueSet ContinuationData { get; }
+ 	public IAsyncOperation<StorageFile> PickSingleFileAsync( string pickSingleFileOperation );
+ 	public void PickSingleFileAndContinue();
+ 	public void PickMultipleFilesAndContinue();
+ 	public static IAsyncOperation<StorageFile> ResumePickSingleFileAsync();
| }

| public class Windows.Storage.Pickers.FileSavePicker {
+ 	public ValueSet ContinuationData { get; }
+ 	public void PickSaveFileAndContinue();
| }

| public class Windows.Storage.Pickers.FolderPicker {
+ 	public ValueSet ContinuationData { get; }
+ 	public void PickFolderAndContinue();
| }

| public class Windows.Storage.Provider.CachedFileUpdaterUI {
+ 	public FileUpdateRequest UpdateRequest { get; }
+ 	public FileUpdateRequestDeferral GetDeferral();
| }

| public class Windows.Storage.Provider.FileUpdateRequest {
+ 	public string UserInputNeededMessage { get; set; }
| }


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

 new file: new\Windows.System.winmd
 old file: old\Windows.System.winmd

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

+ public enum Windows.System.AppMemoryUsageLevel {
+ 	Low = 0,
+ 	Medium = 1,
+ 	High = 2,
+ }

+ public class Windows.System.AppMemoryUsageLimitChangingEventArgs {
+ 	public ulong NewLimit { get; }
+ 	public ulong OldLimit { get; }
+ }

+ public class Windows.System.FolderLauncherOptions {
+ 	public IVector<IStorageItem> ItemsToSelect { get; }
+ 	public ViewSizePreference DesiredRemainingView { get; set; }
+ }

* public interface Windows.System.ILauncherViewOptions;

+ public interface Windows.System.IProtocolForResultsOperationPriv {
+ 	public void ReportCompletedPriv( IBuffer data );
+ }

+ public interface Windows.System.IValueSetProvider {
+ 	public IBuffer Buffer { get; }
+ 	public ValueSet ValueSet { get; }
+ }

+ public enum Windows.System.LaunchUriStatus {
+ 	Success = 0,
+ 	AppUnavailable = 1,
+ 	ProtocolUnavailable = 2,
+ 	Unknown = 3,
+ }

+ public enum Windows.System.LaunchUriType {
+ 	LaunchUri = 0,
+ 	LaunchUriForResults = 1,
+ }

| public class Windows.System.Launcher {
+ 	public static IAsyncOperation<bool> LaunchFolderAsync( IStorageFolder operation );
+ 	public static IAsyncOperation<bool> LaunchFolderAsync( IStorageFolder operation, FolderLauncherOptions folder );
+ 	public static IAsyncOperation<bool> LaunchUriForResultsAndContinueAsync( Uri operation, LauncherOptions uri, ValueSet options );
+ 	public static IAsyncOperation<bool> LaunchUriForResultsAndContinueAsync( Uri operation, LauncherOptions uri, ValueSet options, ValueSet continuationData );
+ 	public static IAsyncOperation<QueryUriSupportStatus> QueryUriSupportAsync( Uri operation, LaunchUriType uri );
+ 	public static IAsyncOperation<QueryUriSupportStatus> QueryUriSupportAsync( Uri operation, LaunchUriType uri, string launchUriType );
| }

+ public class Windows.System.MemoryManager {
+ 	public ulong AppMemoryUsage { get; }
+ 	public AppMemoryUsageLevel AppMemoryUsageLevel { get; }
+ 	public ulong AppMemoryUsageLimit { get; }
+ 	EventHandler<object> AppMemoryUsageDecreased;
+ 	EventHandler<object> AppMemoryUsageIncreased;
+ 	EventHandler<AppMemoryUsageLimitChangingEventArgs> AppMemoryUsageLimitChanging;
+ }

+ public class Windows.System.ProtocolForResultsOperation {
+ 	public void ReportCompleted( ValueSet data );
+ }

+ public enum Windows.System.QueryUriSupportStatus {
+ 	Success = 0,
+ 	AppNotInstalled = 1,
+ 	AppUnavailable = 2,
+ 	ProtocolUnavailable = 3,
+ 	Unknown = 4,
+ }

| public enum Windows.System.VirtualKey {
+ 	NavigationA = 193,
+ 	NavigationB = 194,
+ 	NavigationX = 195,
+ 	NavigationY = 196,
+ 	NavigationUp = 197,
+ 	NavigationDown = 198,
+ 	NavigationLeft = 199,
+ 	NavigationRight = 200,
+ 	NavigationMenu = 201,
+ 	NavigationView = 202,
+ 	NavigationViewUp = 203,
+ 	NavigationViewDown = 204,
+ 	NavigationViewPrevious = 205,
+ 	NavigationViewNext = 206,
| }

+ public struct Windows.System.UserProfile.UserProfileContract {
+ }


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

 new file: new\Windows.UI.winmd
 old file: old\Windows.UI.winmd

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

+ public struct Windows.UI.ApplicationSettings.ApplicationsSettingsContract {
+ }

+ public class Windows.UI.Composition.AnimationExpression {
+ 	public static AnimationExpression Parse( string expression );
+ }

+ public enum Windows.UI.Composition.AsynchronousOperation {
+ 	None = 0,
+ 	Commit = 1,
+ }

+ public class Windows.UI.Composition.AsynchronousOperationFailedEventArgs {
+ 	public HResult HResult { get; }
+ 	public AsynchronousOperation Operation { get; }
+ }

| public class Windows.UI.Composition.ClipInstance : Windows.UI.Composition.CompositionObject {
+ 	public Matrix3x2 Transform { get; set; }
| }

+ public class Windows.UI.Composition.CommittedEventArgs {
+ 	public uint BatchId { get; }
+ }

+ public class Windows.UI.Composition.CommittingEventArgs {
+ 	public uint BatchId { get; }
+ }

+ public class Windows.UI.Composition.CompositionDeferral {
+ 	public void Complete();
+ 	public void Close();
+ }

| public class Windows.UI.Composition.CompositionDevice {
+ 	public ClipInstance CreateClipGroup( IVector<ClipInstance> value );
+ 	public CompositionPropertyBag CreatePropertyBag( CompositionPropertyBagType value );
+ 	public CompositionDeferral GetCommitDeferral();
- 	public CompositionTarget CreateTarget( Interop_Hwnd value );
- 	public void BeginDeferCommit();
- 	public void EndDeferCommit();
| }

+ public class Windows.UI.Composition.CompositionObject {
+ 	public CompositionDevice Device { get; }
+ 	public void Close();
+ }

+ public class Windows.UI.Composition.CompositionPropertyBag {
+ 	public uint GetPropertyIdFromName( string propertyId );
+ 	public void SetFloat( string propertyName, float value );
+ 	public void SetVector2( string propertyName, Vector2 value );
+ 	public void SetVector3( string propertyName, Vector3 value );
+ 	public void SetVector4( string propertyName, Vector4 value );
+ 	public void SetMatrix4x4( string propertyName, Matrix4x4 value );
+ 	public float GetFloat( string value );
+ 	public Vector2 GetVector2( string value );
+ 	public Vector3 GetVector3( string value );
+ 	public Vector4 GetVector4( string value );
+ 	public Matrix4x4 GetMatrix4x4( string value );
+ 	public void BindExpression( int propertyId, AnimationExpression expression );
+ 	public void UnbindExpression( int propertyId );
+ }

+ public enum Windows.UI.Composition.CompositionPropertyBagType {
+ 	Undefined = 0,
+ 	Float = 1,
+ 	Vector2 = 2,
+ 	Vector3 = 3,
+ 	Vector4 = 4,
+ 	Matrix4x4 = 16,
+ }

| public class Windows.UI.Composition.CompositionSurface : Windows.UI.Composition.CompositionObject {
- 	public void Close();
| }

- public class Windows.UI.Composition.CompositionTarget;

+ public interface Windows.UI.Composition.IAnimatableObject {
+ 	public void BindExpression( int propertyId, AnimationExpression expression );
+ 	public void UnbindExpression( int propertyId );
+ }

+ public class Windows.UI.Composition.Interaction {
+ 	public CoreIndependentInputSource InputTarget { get; set; }
+ 	public void AddSupportedInteractions( InteractionConfiguration configuration );
+ 	public void RemoveSupportedInteractions( InteractionConfiguration configuration );
+ 	public void RemoveAllSupportedInteractions();
+ 	public void CapturePointer( uint pointerId );
+ }

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

+ public class Windows.UI.Composition.InteractionMouseConfiguration : Windows.UI.Composition.InteractionConfiguration {
+ }

+ public enum Windows.UI.Composition.InteractionMouseTypes {
+ 	None = 0,
+ 	All = 4294967295,
+ }

+ public class Windows.UI.Composition.InteractionPenConfiguration : Windows.UI.Composition.InteractionConfiguration {
+ }

+ public enum Windows.UI.Composition.InteractionPenTypes {
+ 	None = 0,
+ 	All = 4294967295,
+ }

+ public class Windows.UI.Composition.InteractionTouchConfiguration : Windows.UI.Composition.InteractionConfiguration {
+ }

+ public enum Windows.UI.Composition.InteractionTouchTypes {
+ 	None = 0,
+ 	PanXIncreasing = 1,
+ 	PanXDecreasing = 2,
+ 	PanYIncreasing = 4,
+ 	PanYDecreasing = 8,
+ 	ZoomIncreasing = 16,
+ 	ZoomDecreasing = 32,
+ 	Tap = 64,
+ 	Hold = 128,
+ 	PanX = 3,
+ 	PanY = 12,
+ 	Zoom = 48,
+ 	All = 4294967295,
+ }

+ public class Windows.UI.Composition.InteractionTouchpadConfiguration : Windows.UI.Composition.InteractionConfiguration {
+ }

+ public enum Windows.UI.Composition.InteractionTouchpadTypes {
+ 	None = 0,
+ 	All = 4294967295,
+ }

- public struct Windows.UI.Composition.Interop_Hwnd;

+ public enum Windows.UI.Composition.VisualAnimatableProperties {
+ 	Size = 0,
+ 	Offset = 1,
+ 	Opacity = 2,
+ }

* public class Windows.UI.Composition.VisualCollection : Windows.UI.Composition.CompositionObject;

| public class Windows.UI.Composition.VisualInstance : Windows.UI.Composition.CompositionObject {
+ 	public Interaction Interaction { get; }
+ 	public void HACK_GetSize( ref float xValue, ref float yValue );
+ 	public void HACK_SetSize( float xValue, float yValue );
+ 	public void HACK_GetOffset( ref float xValue, ref float yValue );
+ 	public void HACK_SetOffset( float xValue, float yValue );
+ 	public void BindExpression( int propertyId, AnimationExpression expression );
+ 	public void UnbindExpression( int propertyId );
- 	public void Close();
| }

+ public class Windows.UI.Composition.Core.CompositionRoot {
+ 	public static VisualInstance GetForCurrentView();
+ 	public static void SetForCurrentView( VisualInstance value );
+ }

+ public class Windows.UI.Core.BackRequestedEventArgs {
+ 	public bool Handled { get; set; }
+ }

| public class Windows.UI.Core.CoreIndependentInputSource {
- 	public CoreIndependentInputSource( CoreInputDeviceTypes deviceTypes );
- 	public CoreIndependentInputSource();
| }

+ public class Windows.UI.Core.CoreInput {
+ 	public bool IsInputEnabled { get; set; }
+ 	public CoreDispatcher Dispatcher { get; }
+ 	public CoreCursor PointerCursor { get; set; }
+ 	public bool HasCapture { get; }
+ 	public Point PointerPosition { get; }
+ 	public CoreInput();
+ 	public void ReleasePointerCapture();
+ 	public void SetPointerCapture();
+ 	TypedEventHandler<object, InputEnabledEventArgs> InputEnabled;
+ 	TypedEventHandler<object, PointerEventArgs> PointerCaptureLost;
+ 	TypedEventHandler<object, PointerEventArgs> PointerEntered;
+ 	TypedEventHandler<object, PointerEventArgs> PointerExited;
+ 	TypedEventHandler<object, PointerEventArgs> PointerMoved;
+ 	TypedEventHandler<object, PointerEventArgs> PointerPressed;
+ 	TypedEventHandler<object, PointerEventArgs> PointerReleased;
+ 	TypedEventHandler<object, PointerEventArgs> PointerWheelChanged;
+ }

| public class Windows.UI.Core.CoreWindow {
+ 	public KeyboardInputBuffer KeyboardInputBuffer { get; set; }
+ 	public bool IsKeyboardInputEnabled { get; set; }
| }

+ public interface Windows.UI.Core.ICorePointerRedirector {
+ 	TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerAcquired;
+ 	TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerEnded;
+ 	TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerSuspended;
+ }

+ public class Windows.UI.Core.SystemNavigationManager {
+ 	public static SystemNavigationManager GetForCurrentView();
+ 	EventHandler<BackRequestedEventArgs> BackRequested;
+ }

+ public struct Windows.UI.Core.AnimationMetrics.AnimationMetricsContract {
+ }

| public class Windows.UI.Core.Text.CoreTextCompositionCompletedEventArgs {
+ 	public IVectorView<CoreTextCompositionSegment> CompositionSegments { get; }
| }

+ public class Windows.UI.Core.Text.CoreTextCompositionSegment {
+ 	public CoreTextRange Range { get; set; }
+ 	public string PreconversionString { get; set; }
+ }

+ public class Windows.UI.Core.Text.CoreTextCurrentInputLanguageChangedEventArgs {
+ 	public Language InputLanguage { get; }
+ }

| public class Windows.UI.Core.Text.CoreTextEditContext {
+ 	public CoreTextInputPaneDisplayPolicy InputPaneDisplayPolicy { get; set; }
| }

+ public enum Windows.UI.Core.Text.CoreTextInputPaneDisplayPolicy {
+ 	Automatic = 0,
+ 	Manual = 1,
+ }

+ public class Windows.UI.Core.Text.CoreTextInputServiceContext {
+ 	public Language CurrentInputLanguage { get; }
+ 	TypedEventHandler<CoreTextInputServiceContext, CoreTextCurrentInputLanguageChangedEventArgs> CurrentInputLanguageChanged;
+ }

| public class Windows.UI.Core.Text.CoreTextServicesManager {
+ 	public CoreTextInputServiceContext InputServiceContext { get; }
| }

| public class Windows.UI.Input.PointerPointProperties {
+ 	public IReference<float> ZDistance { get; }
| }

| public class Windows.UI.Input.Inking.DirectInk {
+ 	public InkSynchronizer EnableCustomDry();
| }

- public void delegate Windows.UI.Input.Inking.InkHandler( DirectInk sender, InkEventArgs args );

+ public class Windows.UI.Input.Inking.InkRenderer {
+ 	public InkRenderer();
+ 	public void Draw( IIterable<InkStroke> inkStrokes );
+ }

+ public class Windows.UI.Input.Inking.InkSynchronizer {
+ 	public IVectorView<InkStroke> BeginDry();
+ 	public void EndDry();
+ }

- public void delegate Windows.UI.Input.Inking.InputHandler( DirectInk sender, PointerEventArgs args );

| public class Windows.UI.Notifications.ScheduledToastNotification {
+ 	public string Tag { get; set; }
+ 	public bool SuppressPopup { get; set; }
+ 	public string Group { get; set; }
| }

+ public class Windows.UI.Notifications.TileFlyoutNotification {
+ 	public IReference<DateTime> ExpirationTime { get; set; }
+ 	public XmlDocument Content { get; }
+ 	public TileFlyoutNotification( XmlDocument content );
+ }

+ public enum Windows.UI.Notifications.TileFlyoutTemplateType {
+ 	TileFlyoutTemplate01 = 0,
+ }

+ public class Windows.UI.Notifications.TileFlyoutUpdateManager {
+ 	public static TileFlyoutUpdater CreateTileFlyoutUpdaterForApplication();
+ 	public static TileFlyoutUpdater CreateTileFlyoutUpdaterForApplication( string updater );
+ 	public static TileFlyoutUpdater CreateTileFlyoutUpdaterForSecondaryTile( string updater );
+ 	public static XmlDocument GetTemplateContent( TileFlyoutTemplateType content );
+ }

+ public class Windows.UI.Notifications.TileFlyoutUpdater {
+ 	public NotificationSetting Setting { get; }
+ 	public void Update( TileFlyoutNotification notification );
+ 	public void Clear();
+ 	public void StartPeriodicUpdate( Uri tileFlyoutContent, PeriodicUpdateRecurrence requestedInterval );
+ 	public void StartPeriodicUpdate( Uri tileFlyoutContent, DateTime startTime, PeriodicUpdateRecurrence requestedInterval );
+ 	public void StopPeriodicUpdate();
+ }

+ public enum Windows.UI.Notifications.ToastHistoryChangedType {
+ 	Cleared = 0,
+ 	Removed = 1,
+ 	Expired = 2,
+ 	Added = 3,
+ }

| public class Windows.UI.Notifications.ToastNotification {
+ 	public string Tag { get; set; }
+ 	public bool SuppressPopup { get; set; }
+ 	public string Group { get; set; }
| }

+ public class Windows.UI.Notifications.ToastNotificationHistory {
+ 	public void RemoveGroup( string group );
+ 	public void RemoveGroup( string group, string applicationId );
+ 	public void Remove( string tag, string group, string applicationId );
+ 	public void Remove( string tag, string group );
+ 	public void Remove( string tag );
+ 	public void Clear();
+ 	public void Clear( string applicationId );
+ 	public IVectorView<ToastNotification> GetHistory();
+ 	public IVectorView<ToastNotification> GetHistory( string toasts );
+ }

+ public class Windows.UI.Notifications.ToastNotificationHistoryChangedTriggerDetail {
+ 	public ToastHistoryChangedType ChangeType { get; }
+ }

| public class Windows.UI.Notifications.ToastNotificationManager {
+ 	public ToastNotificationHistory History { get; }
| }

| public class Windows.UI.StartScreen.SecondaryTileVisualElements {
+ 	public Uri Square71x71Logo { get; set; }
| }

| public class Windows.UI.ViewManagement.ApplicationView {
+ 	public bool SuppressSystemOverlays { get; set; }
+ 	public ApplicationViewBoundsMode DesiredBoundsMode { get; }
+ 	public Rect VisibleBounds { get; }
+ 	public FullScreenSystemOverlayMode FullScreenSystemOverlayMode { get; set; }
+ 	public bool IsFullScreenMode { get; }
+ 	public bool SetDesiredBoundsMode( ApplicationViewBoundsMode success );
+ 	public bool TryEnterFullScreenMode();
+ 	public void ExitFullScreenMode();
+ 	public void ShowStandardSystemOverlays();
| }

+ public enum Windows.UI.ViewManagement.ApplicationViewBoundsMode {
+ 	UseVisible = 0,
+ 	UseCoreWindow = 1,
+ }

| public class Windows.UI.ViewManagement.ApplicationViewTitleBar {
+ 	public bool ExtendViewIntoTitleBar { get; set; }
+ 	public double Height { get; }
+ 	public bool IsVisible { get; }
+ 	public double SystemOverlayLeftInset { get; }
+ 	public double SystemOverlayRightInset { get; }
| }

+ public enum Windows.UI.ViewManagement.FullScreenSystemOverlayMode {
+ 	Standard = 0,
+ 	Minimal = 1,
+ }

| public class Windows.UI.ViewManagement.InputPane {
+ 	public bool TryShow();
+ 	public bool TryHide();
| }

+ public class Windows.UI.WebUI.WebUIAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public string Verb { get; }
+ 	public IReference<DateTime> InstanceStartDate { get; }
+ 	public string LocalId { get; }
+ 	public string RoamingId { get; }
+ 	public ActivatedOperation ActivatedOperation { get; }
+ }

+ public class Windows.UI.WebUI.WebUIFileOpenPickerContinuationEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public IVectorView<StorageFile> Files { get; }
+ 	public ActivatedOperation ActivatedOperation { get; }
+ }

+ public class Windows.UI.WebUI.WebUIFileSavePickerContinuationEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public StorageFile File { get; }
+ 	public ActivatedOperation ActivatedOperation { get; }
+ }

+ public class Windows.UI.WebUI.WebUIFolderPickerContinuationEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public StorageFolder Folder { get; }
+ 	public ActivatedOperation ActivatedOperation { get; }
+ }

+ public class Windows.UI.WebUI.WebUIWalletActionActivatedEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public string ActionId { get; }
+ 	public WalletActionKind ActionKind { get; }
+ 	public string ItemId { get; }
+ 	public ActivatedOperation ActivatedOperation { get; }
+ }

+ public class Windows.UI.WebUI.WebUIWebAuthenticationBrokerContinuationEventArgs {
+ 	public ActivationKind Kind { get; }
+ 	public ApplicationExecutionState PreviousExecutionState { get; }
+ 	public SplashScreen SplashScreen { get; }
+ 	public ValueSet ContinuationData { get; }
+ 	public WebAuthenticationResult WebAuthenticationResult { get; }
+ 	public ActivatedOperation ActivatedOperation { get; }
+ }


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

 new file: new\Windows.UI.Xaml.winmd
 old file: old\Windows.UI.Xaml.winmd

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

+ public class Windows.UI.Xaml.AdaptiveTrigger : Windows.UI.Xaml.StateTrigger {
+ 	public double MinWindowWidth { get; set; }
+ 	public double MinWindowHeight { get; set; }
+ 	public DependencyProperty MinWindowHeightProperty { get; }
+ 	public DependencyProperty MinWindowWidthProperty { get; }
+ 	public AdaptiveTrigger();
+ }

| public class Windows.UI.Xaml.DataTemplate : Windows.UI.Xaml.FrameworkTemplate {
+ 	public TypeName TargetType { get; set; }
+ 	public DependencyProperty ExtensionInstanceProperty { get; }
+ 	public static IDataTemplateExtension GetExtensionInstance( FrameworkElement value );
+ 	public static void SetExtensionInstance( FrameworkElement element, IDataTemplateExtension value );
| }

| public class Windows.UI.Xaml.DragEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ 	public DragVisual DragVisual { get; set; }
+ 	public DragUIOptions DragUIOptions { get; set; }
- 	public CoreDragUI Visual { get; }
| }

| public class Windows.UI.Xaml.DragStartingEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ 	public Point DragVisualOffset { get; set; }
+ 	public DragVisualKind DragVisualKind { get; set; }
- 	public DragVisualOptions DragVisualOptions { get; set; }
| }

| public class Windows.UI.Xaml.DragVisual {
+ 	public static DragVisual CreateFromBitmap( BitmapImage returnValue );
- 	public DragVisual();
| }

+ public enum Windows.UI.Xaml.DragVisualKind {
+ 	Automatic = 0,
+ 	DraggedUIElement = 1,
+ 	CustomDragVisual = 2,
+ 	DataFormat = 3,
+ }

- public enum Windows.UI.Xaml.DragVisualOptions;

| public class Windows.UI.Xaml.DropCompletedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ 	public DataPackageOperation DropResult { get; }
- 	public DataPackageOperation DropStatus { get; }
| }

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

+ public interface Windows.UI.Xaml.IDataTemplateExtension {
+ 	public void ResetTemplate();
+ 	public bool ProcessBinding( uint returnValue );
+ }

| public class Windows.UI.Xaml.Setter : Windows.UI.Xaml.SetterBase {
+ 	public TargetPropertyPath Target { get; set; }
| }

+ public class Windows.UI.Xaml.StateTrigger : Windows.UI.Xaml.DependencyObject {
+ 	protected StateTrigger();
+ }

+ public class Windows.UI.Xaml.TargetPropertyPath {
+ 	public object Target { get; set; }
+ 	public PropertyPath Path { get; set; }
+ 	public TargetPropertyPath();
+ }

| public class Windows.UI.Xaml.UIElement : Windows.UI.Xaml.DependencyObject {
+ 	public bool CanDrag { get; set; }
+ 	public DependencyProperty CanDragProperty { get; }
- 	public bool IsDraggable { get; set; }
- 	public DependencyProperty IsDraggableProperty { get; }
| }

| public class Windows.UI.Xaml.VisualState : Windows.UI.Xaml.DependencyObject {
+ 	public SetterBaseCollection Setters { get; }
+ 	public IVector<StateTrigger> StateTriggers { get; }
| }

| public class Windows.UI.Xaml.Automation.Peers.AutomationPeer : Windows.UI.Xaml.DependencyObject {
+ 	public static RawElementProviderRuntimeId GenerateRawElementProviderRuntimeId();
- 	public static UiaRuntimeId GenerateUiaRuntimeId();
| }

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

- public struct Windows.UI.Xaml.Automation.Peers.UiaRuntimeId;

+ public class Windows.UI.Xaml.Controls.CalendarPicker : Windows.UI.Xaml.Controls.Control {
+ 	public bool IsCalendarOpen { get; set; }
+ 	public DayOfWeek FirstDayOfWeek { get; set; }
+ 	public bool IsOutOfScopeEnabled { get; set; }
+ 	public CalendarViewDisplayMode DisplayMode { get; set; }
+ 	public string DayOfWeekFormat { get; set; }
+ 	public string CalendarIdentifier { get; set; }
+ 	public string DateFormat { get; set; }
+ 	public DateTime Date { get; set; }
+ 	public DateTime MinDate { get; set; }
+ 	public Style CalendarViewStyle { get; set; }
+ 	public string PlaceholderText { get; set; }
+ 	public DateTime MaxDate { get; set; }
+ 	public IIterable<string> Languages { get; set; }
+ 	public bool IsTodayHighlighted { get; set; }
+ 	public bool IsLabelVisible { get; set; }
+ 	public DependencyProperty CalendarIdentifierProperty { get; }
+ 	public DependencyProperty CalendarViewStyleProperty { get; }
+ 	public DependencyProperty DateFormatProperty { get; }
+ 	public DependencyProperty DateProperty { get; }
+ 	public DependencyProperty DayOfWeekFormatProperty { get; }
+ 	public DependencyProperty DisplayModeProperty { get; }
+ 	public DependencyProperty FirstDayOfWeekProperty { get; }
+ 	public DependencyProperty IsCalendarOpenProperty { get; }
+ 	public DependencyProperty IsLabelVisibleProperty { get; }
+ 	public DependencyProperty IsOutOfScopeEnabledProperty { get; }
+ 	public DependencyProperty IsTodayHighlightedProperty { get; }
+ 	public DependencyProperty LanguagesProperty { get; }
+ 	public DependencyProperty MaxDateProperty { get; }
+ 	public DependencyProperty MinDateProperty { get; }
+ 	public DependencyProperty PlaceholderTextProperty { get; }
+ 	public CalendarPicker();
+ 	public void SetDisplayDate( DateTime date );
+ 	public void SetYearDecadeDisplayDimensions( int columns, int rows );
+ 	TypedEventHandler<CalendarPicker, CalendarPickerSelectedDateChangedEventArgs> CalendarPickerSelectedDateChanged;
+ 	TypedEventHandler<CalendarPicker, CalendarPickerSelectedDateErrorEventArgs> CalendarPickerSelectedDateError;
+ 	Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventHandler CalendarViewDayItemChanging;
+ 	EventHandler<object> Closed;
+ 	EventHandler<object> Opened;
+ }

+ public class Windows.UI.Xaml.Controls.CalendarPickerSelectedDateChangedEventArgs {
+ 	public IReference<DateTime> NewDate { get; }
+ 	public IReference<DateTime> OldDate { get; }
+ }

+ public class Windows.UI.Xaml.Controls.CalendarPickerSelectedDateErrorEventArgs {
+ 	public DateTime IncorrectValue { get; }
+ 	public string Message { get; }
+ }

+ public class Windows.UI.Xaml.Controls.CalendarView : Windows.UI.Xaml.Controls.Control {
+ 	public Brush CalendarItemForeground { get; set; }
+ 	public Thickness CalendarItemBorderThickness { get; set; }
+ 	public Brush CalendarItemBackground { get; set; }
+ 	public string CalendarIdentifier { get; set; }
+ 	public Brush BlackoutForeground { get; set; }
+ 	public Style CalendarViewDayItemStyle { get; set; }
+ 	public CalendarViewDisplayMode DisplayMode { get; set; }
+ 	public string DayOfWeekFormat { get; set; }
+ 	public FontStyle FirstOfMonthLabelFontStyle { get; set; }
+ 	public FontStyle DayItemFontStyle { get; set; }
+ 	public double DayItemFontSize { get; set; }
+ 	public FontFamily DayItemFontFamily { get; set; }
+ 	public DayOfWeek FirstDayOfWeek { get; set; }
+ 	public double FirstOfYearDecadeLabelFontSize { get; set; }
+ 	public FontFamily FirstOfYearDecadeLabelFontFamily { get; set; }
+ 	public FontWeight FirstOfMonthLabelFontWeight { get; set; }
+ 	public FontWeight DayItemFontWeight { get; set; }
+ 	public double FirstOfMonthLabelFontSize { get; set; }
+ 	public FontFamily FirstOfMonthLabelFontFamily { get; set; }
+ 	public Brush HoverBorderBrush { get; set; }
+ 	public HorizontalAlignment HorizontalFirstOfMonthLabelAlignment { get; set; }
+ 	public HorizontalAlignment HorizontalDayItemAlignment { get; set; }
+ 	public Brush CalendarItemBorderBrush { get; set; }
+ 	public Brush FocusBorderBrush { get; set; }
+ 	public FontWeight FirstOfYearDecadeLabelFontWeight { get; set; }
+ 	public FontStyle FirstOfYearDecadeLabelFontStyle { get; set; }
+ 	public bool IsLabelVisible { get; set; }
+ 	public FontFamily MonthYearItemFontFamily { get; set; }
+ 	public DateTime MinDate { get; set; }
+ 	public DateTime MaxDate { get; set; }
+ 	public IIterable<string> Languages { get; set; }
+ 	public bool IsTodayHighlighted { get; set; }
+ 	public bool IsOutOfScopeEnabled { get; set; }
+ 	public Brush OutOfScopeForeground { get; set; }
+ 	public Brush OutOfScopeBackground { get; set; }
+ 	public int NumberOfWeeksInView { get; set; }
+ 	public FontWeight MonthYearItemFontWeight { get; set; }
+ 	public FontStyle MonthYearItemFontStyle { get; set; }
+ 	public double MonthYearItemFontSize { get; set; }
+ 	public Brush SelectedHoverBorderBrush { get; set; }
+ 	public Brush SelectedForeground { get; set; }
+ 	public Brush SelectedPressedBorderBrush { get; set; }
+ 	public Brush SelectedBorderBrush { get; set; }
+ 	public Brush PressedForeground { get; set; }
+ 	public Brush PressedBorderBrush { get; set; }
+ 	public VerticalAlignment VerticalFirstOfMonthLabelAlignment { get; set; }
+ 	public VerticalAlignment VerticalDayItemAlignment { get; set; }
+ 	public Brush TodayForeground { get; set; }
+ 	public FontWeight TodayFontWeight { get; set; }
+ 	public CalendarViewSelectionMode SelectionMode { get; set; }
+ 	public IVector<DateTime> SelectedDates { get; }
+ 	public CalendarViewTemplateSettings TemplateSettings { get; }
+ 	public DependencyProperty BlackoutForegroundProperty { get; }
+ 	public DependencyProperty CalendarIdentifierProperty { get; }
+ 	public DependencyProperty CalendarItemBackgroundProperty { get; }
+ 	public DependencyProperty CalendarItemBorderBrushProperty { get; }
+ 	public DependencyProperty CalendarItemBorderThicknessProperty { get; }
+ 	public DependencyProperty CalendarItemForegroundProperty { get; }
+ 	public DependencyProperty CalendarViewDayItemStyleProperty { get; }
+ 	public DependencyProperty DayItemFontFamilyProperty { get; }
+ 	public DependencyProperty DayItemFontSizeProperty { get; }
+ 	public DependencyProperty DayItemFontStyleProperty { get; }
+ 	public DependencyProperty DayItemFontWeightProperty { get; }
+ 	public DependencyProperty DayOfWeekFormatProperty { get; }
+ 	public DependencyProperty DisplayModeProperty { get; }
+ 	public DependencyProperty FirstDayOfWeekProperty { get; }
+ 	public DependencyProperty FirstOfMonthLabelFontFamilyProperty { get; }
+ 	public DependencyProperty FirstOfMonthLabelFontSizeProperty { get; }
+ 	public DependencyProperty FirstOfMonthLabelFontStyleProperty { get; }
+ 	public DependencyProperty FirstOfMonthLabelFontWeightProperty { get; }
+ 	public DependencyProperty FirstOfYearDecadeLabelFontFamilyProperty { get; }
+ 	public DependencyProperty FirstOfYearDecadeLabelFontSizeProperty { get; }
+ 	public DependencyProperty FirstOfYearDecadeLabelFontStyleProperty { get; }
+ 	public DependencyProperty FirstOfYearDecadeLabelFontWeightProperty { get; }
+ 	public DependencyProperty FocusBorderBrushProperty { get; }
+ 	public DependencyProperty HorizontalDayItemAlignmentProperty { get; }
+ 	public DependencyProperty HorizontalFirstOfMonthLabelAlignmentProperty { get; }
+ 	public DependencyProperty HoverBorderBrushProperty { get; }
+ 	public DependencyProperty IsLabelVisibleProperty { get; }
+ 	public DependencyProperty IsOutOfScopeEnabledProperty { get; }
+ 	public DependencyProperty IsTodayHighlightedProperty { get; }
+ 	public DependencyProperty LanguagesProperty { get; }
+ 	public DependencyProperty MaxDateProperty { get; }
+ 	public DependencyProperty MinDateProperty { get; }
+ 	public DependencyProperty MonthYearItemFontFamilyProperty { get; }
+ 	public DependencyProperty MonthYearItemFontSizeProperty { get; }
+ 	public DependencyProperty MonthYearItemFontStyleProperty { get; }
+ 	public DependencyProperty MonthYearItemFontWeightProperty { get; }
+ 	public DependencyProperty NumberOfWeeksInViewProperty { get; }
+ 	public DependencyProperty OutOfScopeBackgroundProperty { get; }
+ 	public DependencyProperty OutOfScopeForegroundProperty { get; }
+ 	public DependencyProperty PressedBorderBrushProperty { get; }
+ 	public DependencyProperty PressedForegroundProperty { get; }
+ 	public DependencyProperty SelectedBorderBrushProperty { get; }
+ 	public DependencyProperty SelectedDatesProperty { get; }
+ 	public DependencyProperty SelectedForegroundProperty { get; }
+ 	public DependencyProperty SelectedHoverBorderBrushProperty { get; }
+ 	public DependencyProperty SelectedPressedBorderBrushProperty { get; }
+ 	public DependencyProperty SelectionModeProperty { get; }
+ 	public DependencyProperty TemplateSettingsProperty { get; }
+ 	public DependencyProperty TodayFontWeightProperty { get; }
+ 	public DependencyProperty TodayForegroundProperty { get; }
+ 	public DependencyProperty VerticalDayItemAlignmentProperty { get; }
+ 	public DependencyProperty VerticalFirstOfMonthLabelAlignmentProperty { get; }
+ 	public CalendarView();
+ 	public void SetDisplayDate( DateTime date );
+ 	public void SetYearDecadeDisplayDimensions( int columns, int rows );
+ 	TypedEventHandler<CalendarView, CalendarViewDayItemChangingEventArgs> CalendarViewDayItemChanging;
+ 	TypedEventHandler<CalendarView, SelectedDatesChangedEventArgs> SelectedDatesChanged;
+ }

+ public class Windows.UI.Xaml.Controls.CalendarViewDayItem : Windows.UI.Xaml.Controls.Control {
+ 	public bool IsBlackout { get; set; }
+ 	public DateTime Date { get; }
+ 	public DependencyProperty DateProperty { get; }
+ 	public DependencyProperty IsBlackoutProperty { get; }
+ 	public CalendarViewDayItem();
+ 	public void SetDensityColors( IIterable<Color> colors );
+ }

+ public class Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs {
+ 	public bool InRecycleQueue { get; }
+ 	public CalendarViewDayItem Item { get; }
+ 	public uint Phase { get; }
+ 	public void RegisterUpdateCallback( TypedEventHandler<CalendarView, CalendarViewDayItemChangingEventArgs> callback );
+ 	public void RegisterUpdateCallback( uint callbackPhase, TypedEventHandler<CalendarView, CalendarViewDayItemChangingEventArgs> callback );
+ }

+ public void delegate Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventHandler( CalendarView sender, CalendarViewDayItemChangingEventArgs e );

+ public enum Windows.UI.Xaml.Controls.CalendarViewDisplayMode {
+ 	Month = 0,
+ 	Year = 1,
+ 	Decade = 2,
+ }

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

| public class Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs {
+ 	public DataPackageOperation DropResult { get; }
- 	public DataPackageOperation DropStatus { get; }
- 	public DragItemsCompletedEventArgs();
| }

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

| public class Windows.UI.Xaml.Controls.ListViewBase : Windows.UI.Xaml.Controls.Primitives.Selector {
+ 	public bool IsMultiSelectCheckBoxEnabled { get; set; }
+ 	public DependencyProperty IsMultiSelectCheckBoxEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.MediaElement : Windows.UI.Xaml.FrameworkElement {
+ 	public CastingSource GetAsCastingSource();
| }

| public class Windows.UI.Xaml.Controls.MediaTransportControls : Windows.UI.Xaml.Controls.Control {
+ 	public bool IsCompact { get; set; }
+ 	public DependencyProperty IsCompactProperty { get; }
+ 	public DependencyProperty DropoutPriorityProperty { get; }
+ 	public static int GetDropoutPriority( UIElement value );
+ 	public static void SetDropoutPriority( UIElement element, int value );
| }

| public class Windows.UI.Xaml.Controls.RelativePanel : Windows.UI.Xaml.Controls.Panel {
+ 	public DependencyProperty AlignBottomWithPanelProperty { get; }
+ 	public DependencyProperty AlignHorizontalCenterWithPanelProperty { get; }
+ 	public DependencyProperty AlignHorizontalCenterWithProperty { get; }
+ 	public DependencyProperty AlignLeftWithPanelProperty { get; }
+ 	public DependencyProperty AlignRightWithPanelProperty { get; }
+ 	public DependencyProperty AlignTopWithPanelProperty { get; }
+ 	public DependencyProperty AlignVerticalCenterWithPanelProperty { get; }
+ 	public DependencyProperty AlignVerticalCenterWithProperty { get; }
- 	public DependencyProperty AlignPanelBottomProperty { get; }
- 	public DependencyProperty AlignPanelLeftProperty { get; }
- 	public DependencyProperty AlignPanelRightProperty { get; }
- 	public DependencyProperty AlignPanelTopProperty { get; }
- 	public DependencyProperty CenterInPanelHorizontallyProperty { get; }
- 	public DependencyProperty CenterInPanelVerticallyProperty { get; }
+ 	public static object GetLeftOf( UIElement value );
+ 	public static void SetLeftOf( UIElement element, object value );
+ 	public static object GetAbove( UIElement value );
+ 	public static void SetAbove( UIElement element, object value );
+ 	public static object GetRightOf( UIElement value );
+ 	public static void SetRightOf( UIElement element, object value );
+ 	public static object GetBelow( UIElement value );
+ 	public static void SetBelow( UIElement element, object value );
+ 	public static object GetAlignHorizontalCenterWith( UIElement value );
+ 	public static void SetAlignHorizontalCenterWith( UIElement element, object value );
+ 	public static object GetAlignVerticalCenterWith( UIElement value );
+ 	public static void SetAlignVerticalCenterWith( UIElement element, object value );
+ 	public static object GetAlignLeftWith( UIElement value );
+ 	public static void SetAlignLeftWith( UIElement element, object value );
+ 	public static object GetAlignTopWith( UIElement value );
+ 	public static void SetAlignTopWith( UIElement element, object value );
+ 	public static object GetAlignRightWith( UIElement value );
+ 	public static void SetAlignRightWith( UIElement element, object value );
+ 	public static object GetAlignBottomWith( UIElement value );
+ 	public static void SetAlignBottomWith( UIElement element, object value );
+ 	public static bool GetAlignLeftWithPanel( UIElement value );
+ 	public static void SetAlignLeftWithPanel( UIElement element, bool value );
+ 	public static bool GetAlignTopWithPanel( UIElement value );
+ 	public static void SetAlignTopWithPanel( UIElement element, bool value );
+ 	public static bool GetAlignRightWithPanel( UIElement value );
+ 	public static void SetAlignRightWithPanel( UIElement element, bool value );
+ 	public static bool GetAlignBottomWithPanel( UIElement value );
+ 	public static void SetAlignBottomWithPanel( UIElement element, bool value );
+ 	public static bool GetAlignHorizontalCenterWithPanel( UIElement value );
+ 	public static void SetAlignHorizontalCenterWithPanel( UIElement element, bool value );
+ 	public static bool GetAlignVerticalCenterWithPanel( UIElement value );
+ 	public static void SetAlignVerticalCenterWithPanel( UIElement element, bool value );
- 	public static bool GetAlignPanelLeft( FrameworkElement value );
- 	public static void SetAlignPanelLeft( FrameworkElement element, bool value );
- 	public static bool GetAlignPanelTop( FrameworkElement value );
- 	public static void SetAlignPanelTop( FrameworkElement element, bool value );
- 	public static bool GetAlignPanelRight( FrameworkElement value );
- 	public static void SetAlignPanelRight( FrameworkElement element, bool value );
- 	public static bool GetAlignPanelBottom( FrameworkElement value );
- 	public static void SetAlignPanelBottom( FrameworkElement element, bool value );
- 	public static bool GetCenterInPanelHorizontally( FrameworkElement value );
- 	public static void SetCenterInPanelHorizontally( FrameworkElement element, bool value );
- 	public static bool GetCenterInPanelVertically( FrameworkElement value );
- 	public static void SetCenterInPanelVertically( FrameworkElement element, bool value );
| }

| public class Windows.UI.Xaml.Controls.RichEditBox : Windows.UI.Xaml.Controls.Control {
| }

| public class Windows.UI.Xaml.Controls.ScrollViewer : Windows.UI.Xaml.Controls.ContentControl {
| }

+ public class Windows.UI.Xaml.Controls.SelectedDatesChangedEventArgs {
+ 	public IVectorView<DateTime> AddedDates { get; }
+ 	public IVectorView<DateTime> RemovedDates { get; }
+ }

| public class Windows.UI.Xaml.Controls.TextBox : Windows.UI.Xaml.Controls.Control {
| }

+ public class Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs {
+ 	public int Length { get; }
+ 	public int StartIndex { get; }
+ }

+ public class Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs {
+ 	public int Length { get; }
+ 	public int StartIndex { get; }
+ }

+ public class Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs {
+ 	public int Length { get; }
+ 	public int StartIndex { get; }
+ }

| public class Windows.UI.Xaml.Controls.WebView : Windows.UI.Xaml.FrameworkElement {
+ 	public void AddWebAllowedObject( string name, object pObject );
- 	public void AddApplicationObject( string name, object pObject );
| }

- public class Windows.UI.Xaml.Controls.Primitives.CalendarView : Windows.UI.Xaml.Controls.Control;

- public class Windows.UI.Xaml.Controls.Primitives.CalendarViewDayItem : Windows.UI.Xaml.Controls.Control;

- public class Windows.UI.Xaml.Controls.Primitives.CalendarViewDayItemChangingEventArgs;

- public enum Windows.UI.Xaml.Controls.Primitives.CalendarViewDisplayMode;

- public class Windows.UI.Xaml.Controls.Primitives.CalendarViewSelectedDatesChangedEventArgs;

- public enum Windows.UI.Xaml.Controls.Primitives.CalendarViewSelectionMode;

+ public struct Windows.UI.Xaml.Hosting.HostingContract {
+ }

| public enum Windows.UI.Xaml.Input.InputScopeNameValue {
+ 	NumericPin = 64,
+ 	AlphanumericPin = 65,
| }

+ public class Windows.UI.Xaml.Markup.XamlBindingHelper {
+ 	public static void SuspendRendering( UIElement target );
+ 	public static void ResumeRendering( UIElement target );
+ }

+ public class Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs {
+ 	public FailedMediaStreamKind StreamKind { get; }
+ 	public PartialMediaFailureDetectedEventArgs();
+ }

| public class Windows.UI.Xaml.Media.TimedTextCue {
* 	public TimeSpan StartTime { get; set; }
* 	public TimeSpan Duration { get; set; }
+ 	public IVector<TimedTextLine> Lines { get; }
- 	public int LineCount { get; set; }
- 	public TimedTextLine GetLine( int returnValue );
| }

| public class Windows.UI.Xaml.Media.TimedTextLine {
+ 	public IVector<TimedTextSubformat> Subformats { get; }
- 	public int SubformattingCount { get; set; }
- 	public TimedTextSubformat GetSubformat( int returnValue );
| }

| public class Windows.UI.Xaml.Media.TimedTextRegion {
+ 	public HorizontalAlignment HorizontalAlignment { get; set; }
+ 	public Size Extent { get; set; }
- 	public double ExtentWidth { get; set; }
- 	public VerticalAlignment VerticalAlignment { get; set; }
- 	public double ExtentHeight { get; set; }
| }


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

 new file: new\Windows.Web.winmd
 old file: old\Windows.Web.winmd

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

| public enum Windows.Web.Http.HttpVersion {
+ 	Http20 = 3,
| }

| public class Windows.Web.Http.Diagnostics.HttpDiagnosticProvider {
- 	public bool IsStarted { get; }
| }

+ public class Windows.Web.Http.Diagnostics.HttpDiagnosticProviderActivityCompletedEventArgs {
+ 	public Guid ActivityId { get; }
+ 	public Uri RequestedUri { get; }
+ 	public HttpDiagnosticProviderActivityTimestamps Timestamps { get; }
+ }

+ public class Windows.Web.Http.Diagnostics.HttpDiagnosticProviderActivityTimestamps {
+ 	public IReference<DateTime> CacheCheckedTimestamp { get; }
+ 	public IReference<DateTime> ConnectionCompletedTimestamp { get; }
+ 	public IReference<DateTime> ConnectionInitiatedTimestamp { get; }
+ 	public IReference<DateTime> NameResolvedTimestamp { get; }
+ 	public IReference<DateTime> RequestCompletedTimestamp { get; }
+ 	public IReference<DateTime> RequestSentTimestamp { get; }
+ 	public IReference<DateTime> ResponseCompletedTimestamp { get; }
+ 	public IReference<DateTime> ResponseReceivedTimestamp { get; }
+ 	public IReference<DateTime> SslNegotiatedTimestamp { get; }
+ }

| public class Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestRedirectedEventArgs {
+ 	public Uri RedirectUri { get; }
| }

| public class Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs {
+ 	public HttpDiagnosticRequestInitiator Initiator { get; }
+ 	public IVectorView<HttpDiagnosticSourceLocation> SourceLocations { get; }
| }

+ public enum Windows.Web.Http.Diagnostics.HttpDiagnosticRequestInitiator {
+ 	ParsedElement = 0,
+ 	Script = 1,
+ 	Image = 2,
+ 	Link = 3,
+ 	Style = 4,
+ 	XmlHttpRequest = 5,
+ 	Media = 6,
+ 	HtmlDownload = 7,
+ 	Prefetch = 8,
+ 	Other = 9,
+ }

| public class Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation {
+ 	public ulong ColumnNumber { get; }
| }

| public class Windows.Web.Http.Filters.HttpBaseProtocolFilter {
+ 	public HttpVersion MaxVersion { get; set; }
| }


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

 new file: new\Windows.World.winmd
 old file: old\Windows.World.winmd (NOT EXISTS!)

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

+ public interface Windows.World.ILocatable {
+ 	public Locatability Locatability { get; }
+ 	public Locatability TryGetRelativeTransformTo( ILocatable locatability, ref Matrix4x4 pTarget );
+ }

+ public interface Windows.World.ILocationFactory {
+ 	public Location CreateRelativeTo( ILocatable location, Vector3 pOrigin );
+ }

+ public interface Windows.World.ILocationStatics {
+ 	public LocationStore SavedLocations { get; }
+ 	public Locatability TryCreateRelativeTo( ILocatable locatability, Vector3 pOrigin, ref Location offset );
+ 	public void TryGetRelativeTransformsTo( ILocatable[] locations, ILocatable target, Matrix4x4[] transforms, Locatability[] validities );
+ }

+ public interface Windows.World.IPositionalLocator {
+ 	public PositionalLocatorState State { get; }
+ 	public void RequestActivation();
+ 	TypedEventHandler<IPositionalLocator, object> StateChanged;
+ }

+ public enum Windows.World.Locatability {
+ 	Located = 0,
+ 	Pending = 1,
+ 	UnableToLocate = 2,
+ }

+ public class Windows.World.Location {
+ 	public Locatability Locatability { get; }
+ 	public LocationStore SavedLocations { get; }
+ 	public Location( ILocatable pOrigin, Vector3 offset );
+ 	public Locatability TryGetRelativeTransformTo( ILocatable locatability, ref Matrix4x4 pTarget );
+ 	public static Locatability TryCreateRelativeTo( ILocatable locatability, Vector3 pOrigin, ref Location offset );
+ 	public static void TryGetRelativeTransformsTo( ILocatable[] locations, ILocatable target, Matrix4x4[] transforms, Locatability[] validities );
+ }

+ public class Windows.World.LocationStore {
+ 	public uint Size { get; }
+ 	public Guid Add( Location token );
+ 	public void Remove( Guid token );
+ 	public void Clear();
+ 	public Location Lookup( Guid returnValue );
+ 	public bool HasKey( Guid returnValue );
+ 	public void Split( ref IMapView<Guid, Location> first, ref IMapView<Guid, Location> second );
+ 	public IIterator<IKeyValuePair<Guid, Location>> First();
+ }

+ public enum Windows.World.PositionalLocatorState {
+ 	Unavailable = 0,
+ 	Activating = 1,
+ 	Active = 2,
+ 	Deactivating = 3,
+ 	Inactive = 4,
+ 	Inhibited = 5,
+ }

+ public interface Windows.World.Lighting.Prototype.ILightCubeMapFactory {
+ 	public LightCubeMap CreateLightCubeMap( uint lightCubeMap, float width );
+ }

+ public class Windows.World.Lighting.Prototype.Light {
+ 	public Light();
+ 	public void GetCurrentReading( ref LightSensorReadingRGB pData );
+ 	TypedEventHandler<Light, LightEventArgs> ReadingChanged;
+ }

+ public class Windows.World.Lighting.Prototype.LightCubeMap {
+ 	public LightCubeMap( uint width, float variance );
+ 	public void GetToneMappedTexture( float saturationConstant, float intensityScale, ref IBuffer textureData );
+ 	public void GetHighDynamicRangeTexture( ref IBuffer textureData );
+ 	public void FillTexture( float red, float green, float blue, float alpha );
+ 	TypedEventHandler<LightCubeMap, object> TextureUpdated;
+ }

+ public class Windows.World.Lighting.Prototype.LightEventArgs {
+ 	public LightSensorReadingRGB LightSensorReadingRGB { get; }
+ }

+ public struct Windows.World.Lighting.Prototype.LightSensorReadingRGB {
+ 	public float RedIlluminanceInLux;
+ 	public float GreenIlluminanceInLux;
+ 	public float BlueIlluminanceInLux;
+ 	public float IlluminanceInLux;
+ }

+ public class Windows.World.Sensors.ActiveChangedEventArgs {
+ }

+ public class Windows.World.Sensors.AvailableChangedEventArgs {
+ }

+ public class Windows.World.Sensors.CoordinateMapper {
+ 	public Vector3 Register( Vector3 value );
+ 	public void Register( Vector3[] coords, Vector3[] results );
+ 	public void RegisterDepth( ushort[] depths, Vector3[] results );
+ 	public Vector3 Transform( Vector3 value );
+ 	public void Transform( Vector3[] coords, Vector3[] results );
+ 	public IReference<Matrix4x4> TryGetTransformMatrix();
+ 	public Vector3 Project( Vector3 value );
+ 	public void Project( Vector3[] coords, Vector3[] results );
+ 	public Vector3 Unproject( Vector3 value );
+ 	public void Unproject( Vector3[] coords, Vector3[] results );
+ 	public void UnprojectDepth( ushort[] depths, Vector3[] results );
+ }

+ public class Windows.World.Sensors.CoordinateTransform {
+ 	public Vector3 Project( Vector3 value );
+ 	public void Project( Vector3[] coords, Vector3[] results );
+ 	public Vector3 Unproject( Vector3 value );
+ 	public void Unproject( Vector3[] coords, Vector3[] results );
+ 	public void UnprojectDepth( ushort[] depths, Vector3[] results );
+ }

+ public class Windows.World.Sensors.EnumerationCompletedEventArgs {
+ }

+ public class Windows.World.Sensors.FrameArrivedEventArgs {
+ 	public FrameReference FrameReference { get; }
+ }

+ public class Windows.World.Sensors.FrameReference {
+ 	public TimeSpan RelativeTime { get; }
+ 	public SensorSource SensorSource { get; }
+ 	public IMediaFrame AcquireFrame();
+ }

+ public enum Windows.World.Sensors.FrameType {
+ 	Unknown = 0,
+ 	Video = 1,
+ }

+ public interface Windows.World.Sensors.ICoordinateTransform {
+ 	public Vector3 Project( Vector3 value );
+ 	public void Project( Vector3[] coords, Vector3[] results );
+ 	public Vector3 Unproject( Vector3 value );
+ 	public void Unproject( Vector3[] coords, Vector3[] results );
+ 	public void UnprojectDepth( ushort[] depths, Vector3[] results );
+ }

+ public interface Windows.World.Sensors.IFrameDescription {
+ }

+ public interface Windows.World.Sensors.ISensorSourceProperties {
+ }

+ public class Windows.World.Sensors.SensorSource {
+ 	public bool Active { get; }
+ 	public bool Available { get; }
+ 	public string DeviceClass { get; }
+ 	public string DisplayName { get; }
+ 	public IFrameDescription FrameDescription { get; }
+ 	public FrameType FrameType { get; }
+ 	public ISensorSourceProperties Properties { get; }
+ 	public SourceType SourceType { get; }
+ 	public string UniqueId { get; }
+ 	public SensorSourceReader OpenReader();
+ 	public IAsyncOperation<CoordinateTransform> GetCoordinateTransformAsync();
+ 	public IAsyncOperation<CoordinateMapper> TryGetCoordinateMapperAsync( SensorSource mapper );
+ 	public static SensorSourceWatcher CreateWatcher();
+ 	TypedEventHandler<SensorSource, ActiveChangedEventArgs> ActiveChanged;
+ 	TypedEventHandler<SensorSource, AvailableChangedEventArgs> AvailableChanged;
+ }

+ public class Windows.World.Sensors.SensorSourceReader {
+ 	public bool Paused { get; set; }
+ 	public SensorSource SensorSource { get; }
+ 	public IMediaFrame AcquireLatestFrame();
+ 	public void Close();
+ 	TypedEventHandler<SensorSourceReader, FrameArrivedEventArgs> FrameArrived;
+ }

+ public class Windows.World.Sensors.SensorSourceWatcher {
+ 	public SensorSourceWatcherStatus Status { get; }
+ 	public void Start();
+ 	public void Stop();
+ 	TypedEventHandler<SensorSourceWatcher, EnumerationCompletedEventArgs> EnumerationCompleted;
+ 	TypedEventHandler<SensorSourceWatcher, SourceAddedEventArgs> SourceAdded;
+ 	TypedEventHandler<SensorSourceWatcher, SourceRemovedEventArgs> SourceRemoved;
+ 	TypedEventHandler<SensorSourceWatcher, StoppedEventArgs> Stopped;
+ }

+ public enum Windows.World.Sensors.SensorSourceWatcherStatus {
+ 	Created = 0,
+ 	Started = 1,
+ 	Aborted = 2,
+ 	Stopped = 3,
+ 	Stopping = 4,
+ 	Completed = 5,
+ }

+ public class Windows.World.Sensors.SourceAddedEventArgs {
+ 	public SensorSource SensorSource { get; }
+ }

+ public class Windows.World.Sensors.SourceRemovedEventArgs {
+ 	public SensorSource SensorSource { get; }
+ }

+ public enum Windows.World.Sensors.SourceType {
+ 	Unknown = 0,
+ 	Infrared = 1,
+ 	Depth = 2,
+ 	Color = 3,
+ }

+ public class Windows.World.Sensors.StoppedEventArgs {
+ }

+ public class Windows.World.Sensors.VideoFrame {
+ 	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 SoftwareBitmap SoftwareBitmap { get; }
+ 	public void Close();
+ }

+ public class Windows.World.Sensors.VideoFrameDescription {
+ 	public int Height { get; }
+ 	public int Width { get; }
+ }

+ public struct Windows.World.Surfaces.BufferDescription {
+ 	public DirectXPixelFormat Format;
+ 	public uint Stride;
+ }

+ public class Windows.World.Surfaces.Surface {
+ 	public OrientedBoundingBox BoundingBox { get; }
+ 	public uint Id { get; }
+ 	public uint IndexCount { get; }
+ 	public ILocatable Parent { get; }
+ 	public BufferDescription TriangleIndicesDescription { get; }
+ 	public uint VertexCount { get; }
+ 	public Matrix4x4 VertexNormalToSurfaceObserverTransform { get; }
+ 	public BufferDescription VertexNormalsDescription { get; }
+ 	public Matrix4x4 VertexPositionToSurfaceObserverTransform { get; }
+ 	public BufferDescription VertexPositionsDescription { get; }
+ 	public IBuffer GetVertexPositions();
+ 	public IBuffer GetVertexNormals();
+ 	public IBuffer GetTriangleIndices();
+ }

+ public struct Windows.World.Surfaces.SurfaceChange {
+ 	public uint Id;
+ 	public SurfaceChangeType Type;
+ }

+ public class Windows.World.Surfaces.SurfaceChangeBatch {
+ 	public SurfaceObservation Surfaces { get; }
+ 	public SurfaceChange[] GetChanges();
+ }

+ public enum Windows.World.Surfaces.SurfaceChangeType {
+ 	Removed = 0,
+ 	Added = 1,
+ 	Updated = 2,
+ }

+ public class Windows.World.Surfaces.SurfaceObservation {
+ 	public uint Size { get; }
+ 	public Locatability Locatability { get; }
+ 	public OrientedBoundingBox BoundingBox { get; }
+ 	public Surface Lookup( uint returnValue );
+ 	public bool HasKey( uint returnValue );
+ 	public void Split( ref IMapView<uint, Surface> first, ref IMapView<uint, Surface> second );
+ 	public IIterator<IKeyValuePair<uint, Surface>> First();
+ 	public Locatability TryGetRelativeTransformTo( ILocatable locatability, ref Matrix4x4 pTarget );
+ }

+ public class Windows.World.Surfaces.SurfaceObserver {
+ 	public Locatability Locatability { get; }
+ 	public SurfaceObserver( ILocatable origin, OrientedBoundingBox boundingBox );
+ 	public SurfaceObserver( ILocatable origin, OrientedBoundingBox boundingBox, double minDesiredFeatureSizeInMeters );
+ 	public SurfaceChangeBatch GetObservedSurfaces();
+ 	public Locatability TryGetRelativeTransformTo( ILocatable locatability, ref Matrix4x4 pTarget );
+ 	public static Locatability TryCreateRelativeTo( ILocatable locatability, OrientedBoundingBox origin, ref SurfaceObserver boundingBox );
+ 	public static Locatability TryCreateRelativeToWithMinFeatureSize( ILocatable locatability, OrientedBoundingBox origin, double boundingBox, ref SurfaceObserver minDesiredFeatureSizeInMeters );
+ 	TypedEventHandler<SurfaceObserver, object> SurfacesChanged;
+ }

+ public class Windows.World.Surfaces.VisibleSurfaceObserver {
+ 	public Locatability Locatability { get; }
+ 	public Frustum CullingFrustum { get; }
+ 	public VisibleSurfaceObserver( uint maxTriangleCount );
+ 	public VisibleSurfaceObserver();
+ 	public Locatability TryGetRelativeTransformTo( ILocatable locatability, ref Matrix4x4 pTarget );
+ 	public SurfaceChangeBatch UpdateCullingFrustum( ILocatable changes, Frustum origin );
+ }

+ public struct Windows.World.Surfaces.Prototype.Intersection {
+ 	public Vector3 Point;
+ 	public Vector3 Normal;
+ 	public double Distance;
+ 	public uint SurfaceId;
+ }

+ public class Windows.World.Surfaces.Prototype.SurfaceAnalyzer {
+ 	public SurfaceAnalyzer();
+ 	public void UpdateAnalysis( SurfaceChangeBatch change );
+ 	public Quaternion GetRoomOrientation();
+ }

+ public class Windows.World.Surfaces.Prototype.Utilities {
+ 	public static IReference<Intersection> IntersectRay( SurfaceObservation intersection, Ray surfaces );
+ }