Windows 10 10061 vs. 10056 WinRT API Changes

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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.ApplicationModel.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.ApplicationModel.winmd

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

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

| public class Windows.ApplicationModel.Appointments.Appointment {
+   public ulong RemoteChangeNumber { get; set; }
+   public AppointmentDetailsKind DetailsKind { get; set; }
-   public ulong ServerChangeNumber { get; set; }
-   public string HtmlDetails { get; set; }
| }

| public class Windows.ApplicationModel.Appointments.AppointmentCalendar {
+   public bool CanCancelMeetings { get; set; }
+   public bool CanNotifyInvitees { get; set; }
+   public bool MustNofityInvitees { get; set; }
+   public bool CanUpdateMeetingResponses { get; set; }
+   public bool CanProposeNewTimeForMeetings { get; set; }
+   public bool CanCreateOrUpdateAppointments { get; set; }
+   public bool CanForwardMeetings { get; set; }
+   public AppointmentCalendarSyncManager SyncManager { get; }
-   public AppointmentCalendarSyncAdapter SyncAdapter { get; }
+   public IAsyncOperation<bool> TryCreateOrUpdateAppointmentAsync( Appointment result, bool appointment );
+   public IAsyncOperation<bool> TryCancelMeetingAsync( Appointment result, string meeting, string subject, bool comment );
+   public IAsyncOperation<bool> TryForwardMeetingAsync( Appointment result, IIterable<AppointmentInvitee> meeting, string invitees, string subject, string forwardHeader );
+   public IAsyncOperation<bool> TryProposeNewTimeForMeetingAsync( Appointment result, DateTime meeting, TimeSpan newStartTime, string newDuration, string subject );
+   public IAsyncOperation<bool> TryUpdateMeetingResponseAsync( Appointment result, AppointmentParticipantResponse meeting, string response, string subject, bool comment );
| }

- public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncAdapter;

+ public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager {
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+   public AppointmentCalendarSyncStatus Status { get; }
+   public IAsyncOperation<bool> SyncAsync();
+   TypedEventHandler<AppointmentCalendarSyncManager, object> SyncStatusChanged;
+ }

| public enum Windows.ApplicationModel.Appointments.AppointmentCalendarSyncStatus {
+   UpToDate = 2,
*   AuthenticationError = 3,
+   PolicyError = 4,
*   UnknownError = 5,
-   NetworkError = 3,
| }

- public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncStatusChangedEventArgs;

+ public enum Windows.ApplicationModel.Appointments.AppointmentDetailsKind {
+   PlainText = 0,
+   Html = 1,
+ }

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

| public class Windows.ApplicationModel.Appointments.AppointmentRecurrence {
+   public string CalendarIdentifier { get; }
| }

| public class Windows.ApplicationModel.Appointments.AppointmentStoreChange {
+   public AppointmentCalendar AppointmentCalendar { get; }
-   public AppointmentCalendar Calendar { get; }
| }

- public class Windows.ApplicationModel.Background.CommunicationBlockingAppSetAsActiveTrigger;

- public class Windows.ApplicationModel.Background.PhoneTrigger;

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

- public class Windows.ApplicationModel.Background.SensorDataThresholdTrigger;

- public enum Windows.ApplicationModel.Calls.PhoneAudioRoutingEndpoint;

+ public class Windows.ApplicationModel.Calls.PhoneCallBlocking {
+   public bool BlockUnknownNumbers { get; set; }
+   public bool BlockPrivateNumbers { get; set; }
+   public static IAsyncOperation<bool> SetCallBlockingListAsync( IIterable<string> result );
+ }

- public class Windows.ApplicationModel.Calls.PhoneCallManager;

- public enum Windows.ApplicationModel.Calls.PhoneCallMedia;

- public class Windows.ApplicationModel.Calls.PhoneCallStore;

- public class Windows.ApplicationModel.Calls.PhoneDialOptions;

- public class Windows.ApplicationModel.Calls.PhoneLine;

- public class Windows.ApplicationModel.Calls.PhoneLineCellularDetails;

- public class Windows.ApplicationModel.Calls.PhoneLineNetworkOperatorDisplayOptions;

- public enum Windows.ApplicationModel.Calls.PhoneLineNetworkOperatorDisplayTextLocation;

- public enum Windows.ApplicationModel.Calls.PhoneLineTransport;

- public class Windows.ApplicationModel.Calls.PhoneLineWatcher;

- public class Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs;

- public enum Windows.ApplicationModel.Calls.PhoneLineWatcherStatus;

- public enum Windows.ApplicationModel.Calls.PhoneNetworkState;

- public enum Windows.ApplicationModel.Calls.PhoneSimState;

- public class Windows.ApplicationModel.Calls.PhoneVoicemail;

- public enum Windows.ApplicationModel.Calls.PhoneVoicemailType;

- public class Windows.ApplicationModel.Calls.VideoCapabilities;

- public class Windows.ApplicationModel.Calls.VideoCapabilitiesManager;

+ public enum Windows.ApplicationModel.Calls.Background.PhoneCallBlockedReason {
+   InCallBlockingList = 0,
+   PrivateNumber = 1,
+   UnknownNumber = 2,
+ }

+ public class Windows.ApplicationModel.Calls.Background.PhoneCallBlockedTriggerDetails {
+   public PhoneCallBlockedReason CallBlockedReason { get; }
+   public Guid LineId { get; }
+   public string PhoneNumber { get; }
+ }

+ public class Windows.ApplicationModel.Calls.Background.PhoneCallOriginDataRequestTriggerDetails {
+   public string PhoneNumber { get; }
+   public Guid RequestId { get; }
+ }

- public class Windows.ApplicationModel.Calls.Background.PhoneCallStateChangedTriggerDetails;

- public enum Windows.ApplicationModel.Calls.Background.PhoneLineChangeType;

- public class Windows.ApplicationModel.Calls.Background.PhoneLineChangedTriggerDetails;

- public enum Windows.ApplicationModel.Calls.Background.PhoneLineProperties;

- public enum Windows.ApplicationModel.Calls.Background.PhoneTriggerType;

- public class Windows.ApplicationModel.Calls.Background.PhoneVoicemailCountChangedTriggerDetails;

+ public class Windows.ApplicationModel.Calls.Provider.PhoneCallOrigin {
+   public string Location { get; set; }
+   public string CategoryDescription { get; set; }
+   public string Category { get; set; }
+   public PhoneCallOrigin();
+ }

+ public class Windows.ApplicationModel.Calls.Provider.PhoneCallOriginManager {
+   public bool IsCurrentAppActiveCallOriginApp { get; }
+   public static void ShowPhoneCallOriginSettingsUI();
+   public static void SetCallOrigin( Guid requestId, PhoneCallOrigin callOrigin );
+ }

| public class Windows.ApplicationModel.Chat.ChatCapabilities {
+   public bool IsOnline { get; }
| }

| public class Windows.ApplicationModel.Chat.ChatConversation {
+   public void NotifyLocalParticipantComposing( string transportId, string participantAddress, bool isComposing );
+   public void NotifyRemoteParticipantComposing( string transportId, string participantAddress, bool isComposing );
-   public void SendLocalParticipantComposing( string transportId, string participantAddress, bool isComposing );
-   public void RaiseRemoteParticipantComposingChanged( string transportId, string participantAddress, bool isComposing );
| }

| public class Windows.ApplicationModel.Chat.ChatMessageAttachment {
*   public double TransferProgress { get; set; }
| }

+ public class Windows.ApplicationModel.Chat.ChatMessageBlocking {
+   public static IAsyncAction MarkMessageAsBlockedAsync( string value, bool localChatMessageId );
+ }

| public class Windows.ApplicationModel.Chat.ChatMessageStore {
+   public IAsyncOperation<ChatMessage> ForwardMessageAsync( string result, IIterable<string> localChatMessageId );
+   public IAsyncOperation<bool> TryCancelDownloadMessageAsync( string result );
+   public IAsyncOperation<bool> TryCancelSendMessageAsync( string result );
-   public IAsyncAction MarkMessageAsFilteredAsync( string result, bool localChatMessageId );
-   public IAsyncAction CancelMessageDownloadAsync( string result );
-   public IAsyncAction CancelMessageUploadAsync( string result );
| }

| public class Windows.ApplicationModel.Chat.ChatMessageTransportConfiguration {
+   public IMapView<string, object> ExtendedProperties { get; }
| }

+ public enum Windows.ApplicationModel.Chat.ChatMessageTransportOperatorReferenceName {
+   Sim = 0,
+   SimUim = 1,
+   Uim = 2,
+ }

+ public class Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableTriggerDetails {
+   public string Text { get; }
+   public string Title { get; }
+ }

| public class Windows.ApplicationModel.Chat.RcsEndUserMessageManager {
| }

| public enum Windows.ApplicationModel.Chat.RcsServiceKind {
+   Capability = 3,
| }

| public class Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs {
-   public bool IsSupported { get; }
| }

- public class Windows.ApplicationModel.CommunicationBlocking.CommunicationBlockingAccessManager;

- public class Windows.ApplicationModel.CommunicationBlocking.CommunicationBlockingAppManager;

- public class Windows.ApplicationModel.CommunicationBlocking.CommunicationBlockingAppSetAsActiveTriggerDetails;

| public class Windows.ApplicationModel.Contacts.Contact {
+   public string TextToneToken { get; set; }
+   public string DisplayNameOverride { get; set; }
+   public string RingToneToken { get; set; }
+   public string SortName { get; }
-   public string RingTonePath { get; set; }
-   public string TextTonePath { get; set; }
-   public string ManualDisplayName { get; set; }
| }

| public enum Windows.ApplicationModel.Contacts.ContactBatchStatus {
+   ServerSearchSyncManagerError = 1,
+   ServerSearchUnknownError = 2,
-   ServerSearchPartnershipError = 1,
| }

| public class Windows.ApplicationModel.Contacts.ContactList {
+   public ContactListSyncManager SyncManager { get; }
-   public ContactListSyncAdapter SyncAdapter { get; }
| }

- public class Windows.ApplicationModel.Contacts.ContactListSyncAdapter;

+ public class Windows.ApplicationModel.Contacts.ContactListSyncManager {
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+   public ContactListSyncStatus Status { get; }
+   public IAsyncOperation<bool> SyncAsync();
+   TypedEventHandler<ContactListSyncManager, object> SyncStatusChanged;
+ }

| public enum Windows.ApplicationModel.Contacts.ContactListSyncStatus {
+   UpToDate = 2,
*   AuthenticationError = 3,
+   PolicyError = 4,
*   UnknownError = 5,
-   NetworkError = 3,
| }

- public class Windows.ApplicationModel.Contacts.ContactListSyncStatusChangedEventArgs;

| public class Windows.ApplicationModel.Contacts.ContactManager {
+   public ContactNameOrder SystemSortOrder { get; set; }
+   public ContactNameOrder SystemDisplayNameOrder { get; set; }
| }

| public class Windows.ApplicationModel.Contacts.ContactMatchReason {
*   public ContactMatchReasonKind Field { get; }
| }

+ public enum Windows.ApplicationModel.Contacts.ContactMatchReasonKind {
+   Name = 0,
+   EmailAddress = 1,
+   PhoneNumber = 2,
+   JobInfo = 3,
+   YomiName = 4,
+   Other = 5,
+ }

- public enum Windows.ApplicationModel.Contacts.ContactMatchReasonType;

+ public enum Windows.ApplicationModel.Contacts.ContactNameOrder {
+   FirstNameLastName = 0,
+   LastNameFirstName = 1,
+ }

| public class Windows.ApplicationModel.Contacts.ContactWebsite {
+   public string RawValue { get; set; }
-   public string RawUri { get; set; }
| }

- public class Windows.ApplicationModel.Core.HolographicApplication;

- public interface Windows.ApplicationModel.Core.IHolographicFrameworkView;

- public interface Windows.ApplicationModel.Core.IHolographicFrameworkViewSource;

- public class Windows.ApplicationModel.CrossSystem.PeerSystem;

- public class Windows.ApplicationModel.CrossSystem.PeerSystemQuery;

| public class Windows.ApplicationModel.DataTransfer.DataPackageView {
+   public IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessAsync();
+   public IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessAsync( string operation );
+   public ProtectionPolicyEvaluationResult UnlockAndAssumeEnterpriseIdentity();
| }

- public enum Windows.ApplicationModel.DataTransfer.EdpPolicyResult;

- public enum Windows.ApplicationModel.Email.AutoReplyMessageResponseKind;

| public class Windows.ApplicationModel.Email.EmailAttachment {
+   public ulong EstimatedDownloadSizeInBytes { get; set; }
-   public ulong Size { get; set; }
| }

| public enum Windows.ApplicationModel.Email.EmailBatchStatus {
+   ServerSearchSyncManagerError = 1,
-   ServerSearchPartnershipError = 1,
| }

- public enum Windows.ApplicationModel.Email.EmailClassification;

| public class Windows.ApplicationModel.Email.EmailConversation {
+   public EmailMessageResponseKind LastEmailResponseKind { get; }
-   public EmailMessageResponseType LastEmailResponseType { get; }
| }

- public class Windows.ApplicationModel.Email.EmailFetchOptions;

| public class Windows.ApplicationModel.Email.EmailFolder {
+   public DateTime LastSuccessfulSyncTime { get; set; }
+   public bool IsSyncEnabled { get; set; }
+   public EmailSpecialFolderKind Kind { get; }
-   public DateTime LastSync { get; set; }
-   public bool IsSyncing { get; set; }
-   public EmailSpecialFolderType SpecialFolderType { get; }
+   public EmailConversationReader GetConversationReader( EmailQueryOptions result );
+   public EmailMessageReader GetMessageReader( EmailQueryOptions result );
| }

+ public class Windows.ApplicationModel.Email.EmailIrmInfo {
+   public bool CanRemoveIrmOnResponse { get; set; }
+   public bool CanPrintData { get; set; }
+   public bool CanModifyRecipientsOnResponse { get; set; }
+   public bool CanForward { get; set; }
+   public bool CanExtractData { get; set; }
+   public bool CanReply { get; set; }
+   public bool CanEdit { get; set; }
+   public EmailIrmTemplate Template { get; set; }
+   public bool IsProgramaticAccessAllowed { get; set; }
+   public bool IsIrmOriginator { get; set; }
+   public DateTime ExpirationDate { get; set; }
+   public bool CanReplyAll { get; set; }
+   public EmailIrmInfo( DateTime expiration, EmailIrmTemplate irmTemplate );
+   public EmailIrmInfo();
+ }

- public enum Windows.ApplicationModel.Email.EmailIrmPermissions;

| public class Windows.ApplicationModel.Email.EmailItemCounts {
-   public uint Total;
-   public uint Unread;
-   public uint Flagged;
-   public uint Urgent;
+   public uint Flagged { get; }
+   public uint Important { get; }
+   public uint Total { get; }
+   public uint Unread { get; }
| }

| public class Windows.ApplicationModel.Email.EmailMailbox {
+   public bool IsDataEncryptedUnderLock { get; }
+   public bool IsOwnedByCurrentApp { get; }
+   public EmailMailboxPolicies Policies { get; }
+   public EmailMailboxSyncManager SyncManager { get; }
-   public SmimeEncryptionAlgorithmNegotiation AllowSmimeEncryptionAlgorithmNegotiation { get; }
-   public bool IsAppOwnedMailbox { get; }
-   public EmailMailboxType MailboxType { get; }
-   public bool MustEncryptSmimeMessages { get; }
-   public bool MustEncryptUnderLockscreen { get; }
-   public bool MustSignSmimeMessages { get; }
-   public bool AllowSmimeSoftCerts { get; }
-   public SmimeEncryptionAlgorithm RequiredSmimeEncryptionAlgorithm { get; }
-   public SmimeSigningAlgorithm RequiredSmimeSigningAlgorithm { get; }
-   public EmailMailboxSyncAdapter SyncAdapter { get; }
+   public EmailConversationReader GetConversationReader( EmailQueryOptions result );
+   public EmailMessageReader GetMessageReader( EmailQueryOptions result );
+   public IAsyncOperation<EmailFolder> GetSpecialFolderAsync( EmailSpecialFolderKind result );
+   public IAsyncAction MarkFolderSyncEnabledAsync( string result, bool folderId );
+   public IAsyncOperation<EmailMessage> CreateResponseMessageAsync( string result, EmailMessageResponseKind messageId, string responseType, EmailMessageBodyKind subject, string responseHeaderType );
+   public IAsyncOperation<bool> TryUpdateMeetingResponseAsync( EmailMessage result, EmailMeetingResponseType meeting, string response, string subject, bool comment );
+   public IAsyncOperation<bool> TryForwardMeetingAsync( EmailMessage result, IIterable<EmailRecipient> meeting, string recipients, EmailMessageBodyKind subject, string forwardHeaderType, string forwardHeader );
+   public IAsyncOperation<bool> TryProposeNewTimeForMeetingAsync( EmailMessage result, DateTime meeting, TimeSpan newStartTime, string newDuration, string subject );
+   public IAsyncOperation<bool> TrySetAutoReplySettingsAsync( EmailMailboxAutoReplySettings result );
+   public IAsyncOperation<EmailMailboxAutoReplySettings> TryGetAutoReplySettingsAsync( EmailMailboxAutoReplyMessageResponseKind autoReplySettings );
-   public IAsyncOperation<IVectorView<EmailIrmTemplate>> GetSupportedIrmTemplatesAsync();
-   public IAsyncAction MarkFolderSyncingAsync( string result, bool folderId );
-   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 SetAutoReplySettingsAsync( EmailMailboxAutoReplySettings result );
-   public IAsyncOperation<EmailMailboxAutoReplySettings> GetAutoReplySettingsAsync( AutoReplyMessageResponseKind autoReplySettings );
| }

| public class Windows.ApplicationModel.Email.EmailMailboxAction {
+   public EmailMailboxActionKind Kind { get; }
-   public EmailMailboxActionType ActionType { get; }
| }

+ public enum Windows.ApplicationModel.Email.EmailMailboxActionKind {
+   MarkMessageAsSeen = 0,
+   MarkMessageRead = 1,
+   ChangeMessageFlagState = 2,
+   MoveMessage = 3,
+   SaveDraft = 4,
+   SendMessage = 5,
+   CreateResponseReplyMessage = 6,
+   CreateResponseReplyAllMessage = 7,
+   CreateResponseForwardMessage = 8,
+   MoveFolder = 9,
+   MarkFolderForSyncEnabled = 10,
+ }

- public enum Windows.ApplicationModel.Email.EmailMailboxActionType;

+ public enum Windows.ApplicationModel.Email.EmailMailboxAllowedSmimeEncryptionAlgorithmNegotiation {
+   None = 0,
+   StrongAlgorithm = 1,
+   AnyAlgorithm = 2,
+ }

| public class Windows.ApplicationModel.Email.EmailMailboxAutoReply {
+   public bool IsEnabled { get; set; }
-   public bool Enabled { get; set; }
| }

+ public enum Windows.ApplicationModel.Email.EmailMailboxAutoReplyMessageResponseKind {
+   Html = 0,
+   PlainText = 1,
+ }

| public class Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings {
*   public EmailMailboxAutoReplyMessageResponseKind ResponseKind { get; set; }
+   public bool IsEnabled { get; set; }
-   public bool Enabled { get; set; }
| }

| public class Windows.ApplicationModel.Email.EmailMailboxCapabilities {
-   InternalOofMessages = 1;
-   ExternalOofMessages = 2;
-   ServerSearch = 4;
-   AllFoldersServerSearch = 8;
-   SubFolderServerSearch = 16;
-   SmartReply = 32;
-   Irm = 64;
-   CanResolveRecipients = 128;
-   CanValidateCertificates = 256;
-   CanCreateMeetings = 512;
-   CanForwardMeetings = 1024;
-   CanRespondToMeetings = 2048;
-   CanSendNewTimeProposals = 4096;
+   public bool CanForwardMeetings { get; }
+   public bool CanGetAndSetExternalAutoReplies { get; }
+   public bool CanGetAndSetInternalAutoReplies { get; }
+   public bool CanProposeNewTimeForMeetings { get; }
+   public bool CanServerSearchFolders { get; }
+   public bool CanServerSearchMailbox { get; }
+   public bool CanSmartSend { get; }
+   public bool CanUpdateMeetingResponses { get; }
| }

+ public class Windows.ApplicationModel.Email.EmailMailboxPolicies {
+   public bool AllowSmimeSoftCertificates { get; }
+   public EmailMailboxAllowedSmimeEncryptionAlgorithmNegotiation AllowedSmimeEncryptionAlgorithmNegotiation { get; }
+   public IReference<EmailMailboxSmimeEncryptionAlgorithm> RequiredSmimeEncryptionAlgorithm { get; }
+   public IReference<EmailMailboxSmimeSigningAlgorithm> RequiredSmimeSigningAlgorithm { get; }
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxSmimeEncryptionAlgorithm {
+   Any = 0,
+   TripleDes = 1,
+   Des = 2,
+   RC2128Bit = 3,
+   RC264Bit = 4,
+   RC240Bit = 5,
+ }

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

- public class Windows.ApplicationModel.Email.EmailMailboxSyncAdapter;

+ public class Windows.ApplicationModel.Email.EmailMailboxSyncManager {
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+   public EmailMailboxSyncStatus Status { get; }
+   public IAsyncOperation<bool> SyncAsync();
+   TypedEventHandler<EmailMailboxSyncManager, object> SyncStatusChanged;
+ }

| public enum Windows.ApplicationModel.Email.EmailMailboxSyncStatus {
+   UpToDate = 2,
*   AuthenticationError = 3,
+   PolicyError = 4,
*   UnknownError = 5,
-   NetworkError = 3,
| }

- public class Windows.ApplicationModel.Email.EmailMailboxSyncStatusChangedEventArgs;

- public enum Windows.ApplicationModel.Email.EmailMailboxType;

| public class Windows.ApplicationModel.Email.EmailMeetingInfo {
+   public ulong RemoteChangeNumber { get; set; }
-   public ulong ServerChangeNumber { get; set; }
| }

| public enum Windows.ApplicationModel.Email.EmailMeetingResponseType {
-   Cancel = 3,
| }

| public class Windows.ApplicationModel.Email.EmailMessage {
+   public uint EstimatedDownloadSizeInBytes { get; set; }
+   public EmailMessageDownloadState DownloadState { get; set; }
+   public bool AllowInternetImages { get; set; }
*   public int OriginalCodePage { get; set; }
+   public EmailMessageResponseKind LastResponseKind { get; set; }
+   public EmailIrmInfo IrmInfo { get; set; }
+   public string InResponseToMessageId { get; }
+   public bool IsServerSearchMessage { get; }
-   public bool AllowInternetImage { get; set; }
-   public EmailIrmTemplate IrmTemplate { get; set; }
-   public EmailIrmPermissions IrmPermissions { get; set; }
-   public uint MessageSize { get; set; }
-   public EmailClassification Classification { get; set; }
-   public IReference<DateTime> IrmExpiration { get; set; }
-   public EmailMessageResponseType ResponseType { get; set; }
-   public uint PreferredCodePage { get; set; }
-   public string BaseMessageIdFromCreateResponse { get; }
-   public bool IsTruncated { get; }
-   public uint TransportCodePage { get; }
+   public IRandomAccessStreamReference GetBodyStream( EmailMessageBodyKind result );
+   public void SetBodyStream( EmailMessageBodyKind type, IRandomAccessStreamReference stream );
| }

+ public enum Windows.ApplicationModel.Email.EmailMessageBodyKind {
+   Html = 0,
+   PlainText = 1,
+ }

- public enum Windows.ApplicationModel.Email.EmailMessageBodyType;

+ public enum Windows.ApplicationModel.Email.EmailMessageDownloadState {
+   PartiallyDownloaded = 0,
+   Downloading = 1,
+   Downloaded = 2,
+   Failed = 3,
+ }

+ public enum Windows.ApplicationModel.Email.EmailMessageResponseKind {
+   None = 0,
+   Reply = 1,
+   ReplyAll = 2,
+   Forward = 3,
+ }

- public enum Windows.ApplicationModel.Email.EmailMessageResponseType;

- public enum Windows.ApplicationModel.Email.EmailMessageTypeFilter;

+ public enum Windows.ApplicationModel.Email.EmailQueryKind {
+   All = 0,
+   Important = 1,
+   Flagged = 2,
+   Unread = 3,
+   Read = 4,
+   Unseen = 5,
+ }

+ public class Windows.ApplicationModel.Email.EmailQueryOptions {
+   public EmailQuerySortProperty SortProperty { get; set; }
+   public EmailQuerySortDirection SortDirection { get; set; }
+   public EmailQueryKind Kind { get; set; }
+   public IVector<string> FolderIds { get; }
+   public EmailQueryTextSearch TextSearch { get; }
+   public EmailQueryOptions( string text );
+   public EmailQueryOptions( string text, EmailQuerySearchFields fields );
+   public EmailQueryOptions();
+ }

+ public enum Windows.ApplicationModel.Email.EmailQuerySearchFields {
+   None = 0,
+   Subject = 1,
+   Sender = 2,
+   Preview = 4,
+   Recipients = 8,
+   All = 4294967295,
+ }

+ public enum Windows.ApplicationModel.Email.EmailQuerySearchScope {
+   Local = 0,
+   Server = 1,
+ }

+ public enum Windows.ApplicationModel.Email.EmailQuerySortDirection {
+   Descending = 0,
+   Ascending = 1,
+ }

+ public enum Windows.ApplicationModel.Email.EmailQuerySortProperty {
+   Date = 0,
+ }

+ public class Windows.ApplicationModel.Email.EmailQueryTextSearch {
+   public string Text { get; set; }
+   public EmailQuerySearchScope SearchScope { get; set; }
+   public EmailQuerySearchFields Fields { get; set; }
+ }

| public class Windows.ApplicationModel.Email.EmailRecipient {
-   public EmailRecipientAddressType AddressType { get; set; }
| }

- public enum Windows.ApplicationModel.Email.EmailRecipientAddressType;

- public enum Windows.ApplicationModel.Email.EmailSearchFields;

- public enum Windows.ApplicationModel.Email.EmailSortDirection;

- public enum Windows.ApplicationModel.Email.EmailSortProperty;

+ public enum Windows.ApplicationModel.Email.EmailSpecialFolderKind {
+   None = 0,
+   Root = 1,
+   Inbox = 2,
+   Outbox = 3,
+   Drafts = 4,
+   DeletedItems = 5,
+   Sent = 6,
+ }

- public enum Windows.ApplicationModel.Email.EmailSpecialFolderType;

| public class Windows.ApplicationModel.Email.EmailStore {
+   public EmailConversationReader GetConversationReader( EmailQueryOptions result );
+   public EmailMessageReader GetMessageReader( EmailQueryOptions result );
| }

- public enum Windows.ApplicationModel.Email.SmimeEncryptionAlgorithm;

- public enum Windows.ApplicationModel.Email.SmimeEncryptionAlgorithmNegotiation;

- public enum Windows.ApplicationModel.Email.SmimeSigningAlgorithm;

- public class Windows.ApplicationModel.Sync.MailContactsCalendarSyncUI;

- public enum Windows.ApplicationModel.Sync.SyncContentType;

+ public enum Windows.ApplicationModel.UserDataAccounts.UserDataAccountContentKinds {
+   Email = 1,
+   Contact = 2,
+   Appointment = 4,
+ }

| public class Windows.ApplicationModel.UserDataAccounts.UserDataAccountManager {
+   public static IAsyncOperation<string> ShowAddAccountAsync( UserDataAccountContentKinds result );
+   public static IAsyncAction ShowAccountSettingsAsync( string result );
+   public static IAsyncAction ShowAccountErrorResolverAsync( string result );
| }

+ public class Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration {
+   public string IncomingServerAddress { get; set; }
+   public string IncomingServerUsername { get; set; }
+   public string EmailAddress { get; set; }
+   public string AccountName { get; set; }
+   public string DeviceAccountTypeId { get; set; }
+   public bool CalendarSyncEnabled { get; set; }
+   public string Domain { get; set; }
+   public int IncomingServerPort { get; set; }
+   public DeviceAccountServerType ServerType { get; set; }
+   public string OutgoingServerUsername { get; set; }
+   public bool ContactsSyncEnabled { get; set; }
+   public bool OutgoingServerRequiresSsl { get; set; }
+   public int OutgoingServerPort { get; set; }
+   public string OutgoingServerAddress { get; set; }
+   public bool EmailSyncEnabled { get; set; }
+   public bool IncomingServerRequiresSsl { get; set; }
+   public DeviceAccountConfiguration();
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountServerType {
+   Exchange = 0,
+   Pop = 1,
+   Imap = 2,
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.SystemAccess.UserDataAccountSystemAccessManager {
+   public static IAsyncOperation<IVectorView<string>> AddAndShowDeviceAccountsAsync( IIterable<DeviceAccountConfiguration> result );
+ }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Data.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Data.winmd

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

 found no differences.

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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Devices.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Devices.winmd

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

| public enum Windows.Devices.AllJoyn.AllJoynAuthenticationMechanism {
*   SrpAnonymous = 1,
*   SrpLogon = 2,
*   EcdheNull = 3,
*   EcdhePsk = 4,
*   EcdheEcdsa = 5,
-   Pin = 1,
-   Rsa = 4,
| }

| public class Windows.Devices.AllJoyn.AllJoynBusAttachment {
| }

+ public class Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs {
+   public ushort AttemptCount { get; }
+   public AllJoynCredentials Credentials { get; }
+   public string PeerUniqueName { get; }
+   public string RequestedUserName { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs {
+   public AllJoynAuthenticationMechanism AuthenticationMechanism { get; }
+   public Certificate PeerCertificate { get; }
+   public SocketSslErrorSeverity PeerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> PeerCertificateErrors { get; }
+   public IVectorView<Certificate> PeerIntermediateCertificates { get; }
+   public string PeerUniqueName { get; }
+   public void Accept();
+   public Deferral GetDeferral();
+ }

- public class Windows.Devices.AllJoyn.AllJoynRequestCredentialsEventArgs;

- public class Windows.Devices.AllJoyn.AllJoynVerifyCredentialsEventArgs;

| public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs {
-   public string DeviceId { get; }
| }

+ public struct Windows.Devices.Printers.PrintersContract {
+ }

- public class Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedDeferral;

| public class Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs {
+   public Print3DWorkflowStatus Status { get; set; }
+   public Print3DWorkflowDetail ExtendedStatus { get; set; }
-   public DateTime Deadline { get; }
-   public Print3DWorkflowResults Results { get; }
-   public Print3DWorkflowPrintRequestedDeferral GetDeferral();
| }

- public class Windows.Devices.Printers.Extensions.Print3DWorkflowResults;

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

- public interface Windows.Devices.Sensors.ISensorDataThreshold;

| public class Windows.Devices.Sensors.Pedometer {
-   public IVectorView<PedometerReading> GetReadingsFromTriggerDetails( SensorDataThresholdTriggerDetails result );
| }

- public class Windows.Devices.Sensors.PedometerDataThreshold;

| public class Windows.Devices.Sensors.PedometerReading {
+   public TimeSpan CumulativeStepsDuration { get; }
| }

| public enum Windows.Devices.Sensors.PedometerStatus {
+   Reset = 3,
-   Error = 3,
| }

| public class Windows.Devices.Sensors.ProximitySensor {
+   public ProximitySensorDisplayOnOffController CreateDisplayOnOffController();
+   public static ProximitySensor FromId( string result );
| }

+ public class Windows.Devices.Sensors.ProximitySensorDisplayOnOffController {
+   public void Close();
+ }

- public class Windows.Devices.Sensors.SensorDataThresholdTriggerDetails;

- public enum Windows.Devices.Sensors.SensorType;

| public interface Windows.Devices.Sms.ISmsMessageBase {
+   public string SimIccId { get; }
| }

| public class Windows.Devices.Sms.SmsAppMessage {
+   public string SimIccId { get; }
| }

| public class Windows.Devices.Sms.SmsBroadcastMessage {
+   public string SimIccId { get; }
| }

+ public class Windows.Devices.Sms.SmsMessageRegistration {
+   public string Id { get; }
+   public IVectorView<SmsMessageRegistration> AllRegistrations { get; }
+   public void Unregister();
+   public static SmsMessageRegistration Register( string value, SmsFilterRules id );
+   TypedEventHandler<SmsMessageRegistration, SmsMessageReceivedTriggerDetails> MessageReceived;
+ }

| public class Windows.Devices.Sms.SmsStatusMessage {
+   public string SimIccId { get; }
| }

| public class Windows.Devices.Sms.SmsTextMessage2 {
+   public string SimIccId { get; }
| }

| public class Windows.Devices.Sms.SmsVoicemailMessage {
+   public string SimIccId { get; }
| }

| public class Windows.Devices.Sms.SmsWapMessage {
+   public string SimIccId { get; }
| }

- public enum Windows.Devices.WiFi.WiFiAccessKind;

| public class Windows.Devices.WiFi.WiFiConnectionResult {
-   public ConnectionProfile ConnectionProfile { get; }
| }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Foundation.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Foundation.winmd

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

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

- public struct Windows.Foundation.Geometry.AlignedBoundingBox;

- public struct Windows.Foundation.Geometry.AxisAngle;

- public struct Windows.Foundation.Geometry.Frustum;

- public struct Windows.Foundation.Geometry.OrientedBoundingBox;

- public struct Windows.Foundation.Geometry.Ray;


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Gaming.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Gaming.winmd (NOT EXISTS!)

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

+ public class Windows.Gaming.Input.Gamepad {
+   public Headset Headset { get; }
+   public int IsWireless { get; }
+   public User User { get; }
+   public GamepadVibration Vibration { get; set; }
+   public IVectorView<Gamepad> Gamepads { get; }
+   public Gamepad();
+   public GamepadReading GetCurrentReading();
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<Gamepad> GamepadAdded;
+   EventHandler<Gamepad> GamepadRemoved;
+ }

+ public enum Windows.Gaming.Input.GamepadButtons {
+   None = 0,
+   Menu = 1,
+   View = 2,
+   A = 4,
+   B = 8,
+   X = 16,
+   Y = 32,
+   DPadUp = 64,
+   DPadDown = 128,
+   DPadLeft = 256,
+   DPadRight = 512,
+   LeftShoulder = 1024,
+   RightShoulder = 2048,
+   LeftThumbstick = 4096,
+   RightThumbstick = 8192,
+ }

+ public struct Windows.Gaming.Input.GamepadReading {
+   public ulong Timestamp;
+   public GamepadButtons Buttons;
+   public double LeftTrigger;
+   public double RightTrigger;
+   public double LeftThumbstickX;
+   public double LeftThumbstickY;
+   public double RightThumbstickX;
+   public double RightThumbstickY;
+ }

+ public struct Windows.Gaming.Input.GamepadVibration {
+   public double LeftMotor;
+   public double RightMotor;
+   public double LeftTrigger;
+   public double RightTrigger;
+ }

+ public class Windows.Gaming.Input.Headset {
+   public string CaptureDeviceId { get; }
+   public string RenderDeviceId { get; }
+   public Headset();
+ }

+ public interface Windows.Gaming.Input.IGameController {
+   public Headset Headset { get; }
+   public int IsWireless { get; }
+   public User User { get; }
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+ }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Globalization.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Globalization.winmd

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

 found no differences.

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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Graphics.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Graphics.winmd

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

- public class Windows.Graphics.Display.StereoHeadMountedDisplay;

- public struct Windows.Graphics.Display.StereoRenderingParameters;

- public struct Windows.Graphics.Display.StereoViewProjection;

- public struct Windows.Graphics.Display.ViewProjection;

- public interface Windows.Graphics.Effects.IGraphicsEffectInput;

+ public interface Windows.Graphics.Effects.IGraphicsEffectSource {
+ }

- public class Windows.Graphics.Holographic.HolographicDisplay;

- public class Windows.Graphics.Holographic.HolographicFrame;

- public class Windows.Graphics.Holographic.HolographicSpace;

- public struct Windows.Graphics.Holographic.MovingFocusPoint;

- public struct Windows.Graphics.Holographic.StereoRenderingParameters;

- public struct Windows.Graphics.Holographic.ViewProjection;

- public class Windows.Graphics.Printing.ModelTexture;

- public class Windows.Graphics.Printing.Print3DManager;

- public class Windows.Graphics.Printing.Print3DModel;

- public class Windows.Graphics.Printing.Print3DModelPackage;

- public class Windows.Graphics.Printing.Print3DTask;

- public class Windows.Graphics.Printing.Print3DTaskCompletedEventArgs;

- public enum Windows.Graphics.Printing.Print3DTaskDetail;

- public class Windows.Graphics.Printing.Print3DTaskRequest;

- public class Windows.Graphics.Printing.Print3DTaskRequestedDeferral;

- public class Windows.Graphics.Printing.Print3DTaskRequestedEventArgs;

- public class Windows.Graphics.Printing.Print3DTaskSourceChangedEventArgs;

- public class Windows.Graphics.Printing.Print3DTaskSourceRequestedArgs;

- public class Windows.Graphics.Printing.Print3DTaskSourceRequestedDeferral;

- public void delegate Windows.Graphics.Printing.Print3DTaskSourceRequestedHandler( Print3DTaskSourceRequestedArgs args );

- public enum Windows.Graphics.Printing.TextureFormat;

+ public class Windows.Graphics.Printing3D.ModelTexture {
+   public TextureFormat Type { get; set; }
+   public string Name { get; set; }
+   public IRandomAccessStreamWithContentType Texture { get; }
+   public void SetTexture( IRandomAccessStreamWithContentType value );
+ }

+ public class Windows.Graphics.Printing3D.Print3DManager {
+   public static Print3DManager GetForCurrentView();
+   public static IAsyncOperation<bool> ShowPrintUIAsync();
+   TypedEventHandler<Print3DManager, Print3DTaskRequestedEventArgs> TaskRequested;
+ }

+ public class Windows.Graphics.Printing3D.Print3DModel {
+   public IVectorView<ModelTexture> Textures { get; set; }
+   public IRandomAccessStreamWithContentType PrintTicket { get; set; }
+   public IRandomAccessStreamWithContentType Model { get; set; }
+ }

+ public class Windows.Graphics.Printing3D.Print3DModelPackage {
+   public IVectorView<ModelTexture> Textures { get; set; }
+   public IRandomAccessStream PrintTicket { get; set; }
+   public IRandomAccessStream Model { get; set; }
+   public IRandomAccessStream Generate3mfPackage();
+   public void LoadPackage( IRandomAccessStream packageStream );
+   public static Print3DModelPackage Get3DModelPackage();
+ }

+ public class Windows.Graphics.Printing3D.Print3DTask {
+   public Print3DModelPackage Source { get; }
+   TypedEventHandler<Print3DTask, Print3DTaskCompletedEventArgs> Completed;
+   TypedEventHandler<Print3DTask, Print3DTaskSourceChangedEventArgs> SourceChanged;
+   TypedEventHandler<Print3DTask, object> Submitting;
+ }

+ public class Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs {
+   public Print3DTaskCompletion Completion { get; }
+   public Print3DTaskDetail ExtendedStatus { get; }
+ }

+ public enum Windows.Graphics.Printing3D.Print3DTaskCompletion {
+   Abandoned = 0,
+   Canceled = 1,
+   Failed = 2,
+   Slicing = 3,
+   Submitted = 4,
+ }

+ public enum Windows.Graphics.Printing3D.Print3DTaskDetail {
+   Unknown = 0,
+   ModelExceedsPrintBed = 1,
+   UploadFailed = 2,
+   InvalidMaterialSelection = 3,
+   InvalidModel = 4,
+   ModelNotManifold = 5,
+   InvalidPrintTicket = 6,
+ }

+ public class Windows.Graphics.Printing3D.Print3DTaskRequest {
+   public Print3DTask CreateTask( string result, string title, Print3DTaskSourceRequestedHandler printerId );
+ }

+ public class Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs {
+   public Print3DTaskRequest Request { get; }
+ }

+ public class Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs {
+   public Print3DModelPackage Source { get; }
+ }

+ public class Windows.Graphics.Printing3D.Print3DTaskSourceRequestedArgs {
+   public void SetSource( Print3DModelPackage source );
+ }

+ public void delegate Windows.Graphics.Printing3D.Print3DTaskSourceRequestedHandler( Print3DTaskSourceRequestedArgs args );

+ public class Windows.Graphics.Printing3D.Printing3D3MFPackage {
+   public Printing3DTextureResource Thumbnail { get; set; }
+   public IRandomAccessStream PrintTicket { get; set; }
+   public IRandomAccessStream ModelPart { get; set; }
+   public IVector<Printing3DTextureResource> Textures { get; }
+   public Printing3D3MFPackage();
+   public IAsyncOperation<IRandomAccessStream> SaveAsync();
+   public IAsyncOperation<Printing3DObject> LoadObject3DFromPackageAsync( IRandomAccessStream operation );
+   public IAsyncAction SaveObject3DToPackageAsync( Printing3DObject operation );
+   public static IAsyncOperation<Printing3D3MFPackage> LoadAsync( IRandomAccessStream operation );
+ }

+ public class Windows.Graphics.Printing3D.Printing3DBaseMaterial {
+   public string Name { get; set; }
+   public Printing3DColorMaterial Color { get; set; }
+   public string Abs { get; }
+   public string Pla { get; }
+   public Printing3DBaseMaterial();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup {
+   public IVector<Printing3DBaseMaterial> Bases { get; }
+   public uint Id { get; }
+   public Printing3DBaseMaterialGroup( uint Id );
+ }

+ public struct Windows.Graphics.Printing3D.Printing3DBufferDescription {
+   public Printing3DBufferFormat Format;
+   public uint Stride;
+ }

+ public enum Windows.Graphics.Printing3D.Printing3DBufferFormat {
+   Unknown = 0,
+   R32G32B32A32Float = 2,
+   R32G32B32A32UInt = 3,
+   R32G32B32Float = 6,
+   R32G32B32UInt = 7,
+ }

+ public class Windows.Graphics.Printing3D.Printing3DColorMaterial {
+   public uint Value { get; set; }
+   public Printing3DColorMaterial();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DColorMaterialGroup {
+   public IVector<Printing3DColorMaterial> Colors { get; }
+   public uint Id { get; }
+   public Printing3DColorMaterialGroup( uint Id );
+ }

+ public class Windows.Graphics.Printing3D.Printing3DComponent {
+   public Printing3DMesh Mesh { get; set; }
+   public Matrix4x4 Matrix { get; set; }
+   public IVector<Printing3DComponent> Components { get; }
+   public Printing3DComponent();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DComponentMaterial {
+   public double Value { get; set; }
+   public uint MaterialIndex { get; set; }
+   public Printing3DComponentMaterial();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DCompositeMaterial {
+   public uint MaterialID { get; set; }
+   public IVector<Printing3DComponentMaterial> Components { get; }
+   public Printing3DCompositeMaterial();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DCompositeMaterialGroup {
+   public IVector<Printing3DCompositeMaterial> Composites { get; }
+   public uint Id { get; }
+   public Printing3DCompositeMaterialGroup( uint Id );
+ }

+ public struct Windows.Graphics.Printing3D.Printing3DContract {
+ }

+ public class Windows.Graphics.Printing3D.Printing3DMaterial {
+   public IVector<Printing3DBaseMaterialGroup> BaseGroups { get; }
+   public IVector<Printing3DColorMaterialGroup> ColorGroups { get; }
+   public IVector<Printing3DCompositeMaterialGroup> CompositeGroups { get; }
+   public IVector<Printing3DTexture2CoordMaterialGroup> Texture2CoordGroups { get; }
+   public Printing3DMaterial();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DMesh {
+   public Printing3DBufferDescription VertexPositionsDescription { get; set; }
+   public Printing3DBufferDescription VertexNormalsDescription { get; set; }
+   public uint VertexCount { get; set; }
+   public Printing3DBufferDescription TriangleMaterialIndicesDescription { get; set; }
+   public Printing3DBufferDescription TriangleIndicesDescription { get; set; }
+   public uint IndexCount { get; set; }
+   public IPropertySet BufferDescriptionSet { get; }
+   public IPropertySet BufferSet { get; }
+   public Printing3DMesh();
+   public IBuffer GetVertexPositions();
+   public IBuffer GetVertexNormals();
+   public IBuffer GetTriangleIndices();
+   public IBuffer GetTriangleMaterialIndices();
+   public IAsyncOperation<Printing3DMeshVerificationResult> VerifyAsync( Printing3DMeshVerificationMode operation );
+ }

+ public enum Windows.Graphics.Printing3D.Printing3DMeshVerificationMode {
+   FindFirstError = 0,
+   FindAllErrors = 1,
+ }

+ public class Windows.Graphics.Printing3D.Printing3DMeshVerificationResult {
+   public bool IsValid { get; }
+   public IVectorView<uint> NonmanifoldTriangles { get; }
+   public IVectorView<uint> ReversedNormalTriangles { get; }
+ }

+ public class Windows.Graphics.Printing3D.Printing3DObject {
+   public IRandomAccessStream Version { get; set; }
+   public Printing3DObjectUnit Unit { get; set; }
+   public Printing3DMaterial Material { get; set; }
+   public Printing3DComponent Build { get; set; }
+   public IVector<Printing3DComponent> Components { get; }
+   public IVector<Printing3DMesh> Meshes { get; }
+   public IMap<string, string> Metadata { get; }
+   public IVector<Printing3DObjectTexture> Textures { get; }
+   public Printing3DObject();
+   public IAsyncAction RepairAsync();
+   public Printing3DObject Clone();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DObjectTexture {
+   public Printing3DTextureEdgeBehavior TileStyleV { get; set; }
+   public Printing3DTextureEdgeBehavior TileStyleU { get; set; }
+   public Printing3DTextureResource TextureResource { get; set; }
+   public Printing3DObjectTexture();
+ }

+ public enum Windows.Graphics.Printing3D.Printing3DObjectUnit {
+   Meter = 0,
+   Micron = 1,
+   Millimeter = 2,
+   Centimeter = 3,
+   Inch = 4,
+   Foot = 5,
+ }

+ public class Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterial {
+   public double V { get; set; }
+   public double U { get; set; }
+   public Printing3DObjectTexture Texture { get; set; }
+   public Printing3DTexture2CoordMaterial();
+ }

+ public class Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterialGroup {
+   public uint Id { get; }
+   public IVector<Printing3DTexture2CoordMaterial> Texture2Coords { get; }
+   public Printing3DTexture2CoordMaterialGroup( uint Id );
+ }

+ public enum Windows.Graphics.Printing3D.Printing3DTextureEdgeBehavior {
+   None = 0,
+   Wrap = 1,
+   Mirror = 2,
+ }

+ public class Windows.Graphics.Printing3D.Printing3DTextureResource {
+   public IRandomAccessStreamWithContentType TextureData { get; set; }
+   public string Name { get; set; }
+   public Printing3DTextureResource();
+ }

+ public enum Windows.Graphics.Printing3D.TextureFormat {
+   Jpeg = 0,
+   Png = 1,
+   Tiff = 2,
+   Tbmp = 3,
+ }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Human.winmd (NOT EXISTS!)
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Human.winmd

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

- public class Windows.Human.Person;

- public class Windows.Human.Pose;

- public class Windows.Human.Gestures.GestureRecognizer;

- public enum Windows.Human.Gestures.GestureSource;

- public class Windows.Human.Gestures.HoldCanceledEventArgs;

- public class Windows.Human.Gestures.HoldCompletedEventArgs;

- public class Windows.Human.Gestures.HoldStartedEventArgs;

- public interface Windows.Human.Gestures.IGestureEventArgs;

- public interface Windows.Human.Gestures.IScrollEventArgs;

- public interface Windows.Human.Gestures.IZoomEventArgs;

- public enum Windows.Human.Gestures.NuiGestureSettings;

- public class Windows.Human.Gestures.ScrollCanceledEventArgs;

- public class Windows.Human.Gestures.ScrollCompletedEventArgs;

- public class Windows.Human.Gestures.ScrollStartedEventArgs;

- public class Windows.Human.Gestures.ScrollUpdatedEventArgs;

- public class Windows.Human.Gestures.SelectDetectedEventArgs;

- public class Windows.Human.Gestures.ZoomCanceledEventArgs;

- public class Windows.Human.Gestures.ZoomCompletedEventArgs;

- public class Windows.Human.Gestures.ZoomStartedEventArgs;

- public class Windows.Human.Gestures.ZoomUpdatedEventArgs;

- public class Windows.Human.Hands.FingerPressedEventArgs;

- public class Windows.Human.Hands.FingerReleasedEventArgs;

- public class Windows.Human.Hands.Hand;

- public class Windows.Human.Hands.HandDetectedEventArgs;

- public class Windows.Human.Hands.HandLostEventArgs;

- public class Windows.Human.Hands.HandMovedEventArgs;

- public enum Windows.Human.Hands.HandState;

- public interface Windows.Human.Hands.IHandEventArgs;

- public enum Windows.Human.Voice.Phrase;

- public class Windows.Human.Voice.VoiceEventArgs;


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Management.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Management.winmd

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

 found no differences.

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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Media.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Media.winmd

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

- public enum Windows.Media.MixedRealityCapture.AudioMixerMode;

- public class Windows.Media.MixedRealityCapture.MixedRealityCaptureAudioEffect;

- public class Windows.Media.MixedRealityCapture.MixedRealityCaptureAudioEffectDefinition;

- public class Windows.Media.MixedRealityCapture.MixedRealityCaptureVideoEffect;

- public class Windows.Media.MixedRealityCapture.MixedRealityCaptureVideoEffectDefinition;

| public class Windows.Media.SpeechRecognition.SpeechRecognitionResult {
+   public TimeSpan PhraseDuration { get; }
+   public DateTime PhraseStartTime { get; }
| }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Networking.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Networking.winmd

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

| public class Windows.Networking.NetworkOperators.MobileBroadbandModem {
+   public MobileBroadbandNetwork CurrentNetwork { get; }
| }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Security.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Security.winmd

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

| public class Windows.Security.Cryptography.Core.EccCurveNames {
+   public string BrainpoolP160r1 { get; }
+   public string BrainpoolP160t1 { get; }
+   public string BrainpoolP192r1 { get; }
+   public string BrainpoolP192t1 { get; }
+   public string BrainpoolP224r1 { get; }
+   public string BrainpoolP224t1 { get; }
+   public string BrainpoolP256r1 { get; }
+   public string BrainpoolP256t1 { get; }
+   public string BrainpoolP320r1 { get; }
+   public string BrainpoolP320t1 { get; }
+   public string BrainpoolP384r1 { get; }
+   public string BrainpoolP384t1 { get; }
+   public string BrainpoolP512r1 { get; }
+   public string BrainpoolP512t1 { get; }
+   public string Curve25519 { get; }
+   public string Ec192wapi { get; }
+   public string NistP192 { get; }
+   public string NistP224 { get; }
+   public string NumsP256t1 { get; }
+   public string NumsP384t1 { get; }
+   public string NumsP512t1 { get; }
+   public string SecP160k1 { get; }
+   public string SecP160r1 { get; }
+   public string SecP160r2 { get; }
+   public string SecP192k1 { get; }
+   public string SecP192r1 { get; }
+   public string SecP224k1 { get; }
+   public string SecP224r1 { get; }
+   public string SecP256k1 { get; }
+   public string SecP256r1 { get; }
+   public string SecP384r1 { get; }
+   public string SecP521r1 { get; }
+   public string Wtls12 { get; }
+   public string Wtls7 { get; }
+   public string Wtls9 { get; }
-   public string Secp256k1 { get; }
-   public string Secp256r1 { get; }
-   public string Secp384r1 { get; }
-   public string Secp521r1 { get; }
-   public string X962P192v4 { get; }
| }

+ public class Windows.Security.EnterpriseData.BufferProtectUnprotectResult {
+   public IBuffer Buffer { get; }
+   public DataProtectionInfo ProtectionInfo { get; }
+ }

| public class Windows.Security.EnterpriseData.DataProtectionManager {
+   public static IAsyncOperation<BufferProtectUnprotectResult> ProtectAsync( IBuffer result, string data );
+   public static IAsyncOperation<BufferProtectUnprotectResult> UnprotectAsync( IBuffer result );
+   public static IAsyncOperation<DataProtectionInfo> ProtectStreamAsync( IInputStream result, string unprotectedStream, IOutputStream identity );
+   public static IAsyncOperation<DataProtectionInfo> UnprotectStreamAsync( IInputStream result, IOutputStream protectedStream );
| }

| public enum Windows.Security.EnterpriseData.DataProtectionStatus {
+   Unprotected = 3,
| }

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

| public class Windows.Security.EnterpriseData.FileProtectionInfo {
+   public string Identity { get; }
| }

+ public class Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs {
+   public IVectorView<string> Identities { get; }
+ }

+ public class Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs {
+   public DateTime Deadline { get; }
+   public IVectorView<string> Identities { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs {
+   public IVectorView<string> Identities { get; }
+ }

- public class Windows.Security.EnterpriseData.ProtectionPolicyEventArgs;


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Services.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Services.winmd

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

| public class Windows.Services.Maps.MapRoute {
-   public bool IsGuidanceRoute { get; }
| }

| public class Windows.Services.Maps.MapRouteDrivingOptions {
+   public uint MaxAlternateRouteCount { get; set; }
+   public IReference<double> InitialHeading { get; set; }
-   public double Heading { get; set; }
-   public uint AlternateRouteCount { get; set; }
| }

| public class Windows.Services.Maps.MapService {
+   public string WorldViewRegionCode { get; }
| }

- public void delegate Windows.Services.Maps.Guidance.EmptyEventHandler();

| public class Windows.Services.Maps.Guidance.GuidanceEngine {
-   public Maneuver AfterNextManeuver { get; }
-   public int AfterNextManeuverDistance { get; }
-   public MapMatchedLocation CurrentLocation { get; }
-   public Geopoint CurrentPosition { get; }
-   public int DestinationDistance { get; }
-   public int ElapsedDistance { get; }
-   public TimeSpan ElapsedTime { get; }
-   public GuidanceMode GuidanceMode { get; }
-   public Maneuver NextManeuver { get; }
-   public int NextManeuverDistance { get; }
-   public string RoadName { get; }
-   public GuidanceRoute Route { get; }
-   public TimeSpan TimeToArrival { get; }
+   public void Navigate( GuidanceRoute value );
+   public void Simulate( MapRoute value, int speed );
+   public void Simulate( GuidanceRoute value, int speed );
+   public void SetVoiceSkin( int skinId, string voicesDirectory );
| }

+ public class Windows.Services.Maps.Guidance.GuidanceEventArgs {
+   public Maneuver AfterNextManeuver { get; }
+   public int AfterNextManeuverDistance { get; }
+   public MapMatchedLocation CurrentLocation { get; }
+   public int DestinationDistance { get; }
+   public int ElapsedDistance { get; }
+   public TimeSpan ElapsedTime { get; }
+   public GuidanceMode GuidanceMode { get; }
+   public bool IsNewManeuverAvailable { get; }
+   public Maneuver NextManeuver { get; }
+   public int NextManeuverDistance { get; }
+   public string RoadName { get; }
+   public GuidanceRoute Route { get; }
+   public TimeSpan TimeToArrival { get; }
+ }

| public class Windows.Services.Maps.Guidance.GuidanceRoute {
*   public TimeSpan Duration { get; }
*   public int Length { get; }
+   public GuidanceRoute( MapRoute mapRoute );
| }

+ public interface Windows.Services.Maps.Guidance.ILaneInfoEventArgs {
+   public IVector<LaneInfo> LaneInfo { get; }
+ }

| public enum Windows.Services.Maps.Guidance.IconId {
+   UTurnRight = 2,
+   UTurnLeft = 3,
+   UTurn = 90,
-   UturnRight = 2,
-   UturnLeft = 3,
-   Uturn = 90,
| }

+ public class Windows.Services.Maps.Guidance.LaneInfo {
+   public int Directions { get; }
+   public bool IsOnRoute { get; }
+ }

+ public enum Windows.Services.Maps.Guidance.LaneInfoDirection {
+   Undefined = 0,
+   SlightlyRight = 1,
+   Right = 2,
+   SharpRight = 4,
+   Straight = 8,
+   UTurnLeft = 16,
+   SharpLeft = 32,
+   Left = 64,
+   SlightlyLeft = 128,
+   UTurnRight = 256,
+   Unknown = 4294967295,
+ }

+ public class Windows.Services.Maps.Guidance.LaneInfoEventArgs {
+   public IVector<LaneInfo> LaneInfo { get; }
+ }

| public class Windows.Services.Maps.Guidance.Maneuver {
*   public int DistanceFromPreviousManeuver { get; }
*   public int DistanceFromStart { get; }
*   public int EndAngle { get; }
*   public int StartAngle { get; }
| }

- public class Windows.Services.Maps.Guidance.ManeuverAvailableArgs;

| public class Windows.Services.Maps.Guidance.MapSensor {
+   public void SetUploadFrequency( int uploadFrequency );
| }

- public enum Windows.Services.Maps.Guidance.RequestState;

| public class Windows.Services.Maps.Guidance.RoadElement {
+   public bool IsTollRoad { get; }
-   public bool IsTollroad { get; }
| }

| public class Windows.Services.Maps.Guidance.Traffic {
*   public TrafficRequestState State { get; }
-   public void Init();
-   public void Poll();
| }

| public class Windows.Services.Maps.Guidance.TrafficEvent {
*   public int EstimatedSpeedLimit { get; }
*   public int SpeedLimit { get; }
| }

+ public class Windows.Services.Maps.Guidance.TrafficEventArgs {
+   public TrafficRequestState State { get; }
+ }

- public void delegate Windows.Services.Maps.Guidance.TrafficEventHandler( Traffic sender );

+ public enum Windows.Services.Maps.Guidance.TrafficRequestState {
+   Error = 0,
+   Idle = 1,
+   Done = 2,
+   Busy = 3,
+   Decoding = 4,
+   Requesting = 5,
+ }

- public class Windows.Services.Maps.Local.LocalCategories;

- public class Windows.Services.Maps.Local.LocalLocation;

- public class Windows.Services.Maps.Local.LocalLocationFinder;

- public class Windows.Services.Maps.Local.LocalLocationFinderResult;

- public enum Windows.Services.Maps.Local.LocalLocationFinderStatus;

+ public class Windows.Services.Maps.LocalSearch.LocalCategories {
+   public string All { get; }
+   public string BankAndCreditUnions { get; }
+   public string EatDrink { get; }
+   public string Hospitals { get; }
+   public string HotelsAndMotels { get; }
+   public string Parking { get; }
+   public string SeeDo { get; }
+   public string Shop { get; }
+ }

+ public class Windows.Services.Maps.LocalSearch.LocalLocation {
+   public MapAddress Address { get; }
+   public string DataAttribution { get; }
+   public string Description { get; }
+   public string DisplayName { get; }
+   public string Identifier { get; }
+   public string PhoneNumber { get; }
+   public Geopoint Point { get; }
+ }

+ public class Windows.Services.Maps.LocalSearch.LocalLocationFinder {
+   public static IAsyncOperation<LocalLocationFinderResult> FindLocalLocationsAsync( string result, Geocircle searchTerm, string searchArea, uint localCategory );
+ }

+ public class Windows.Services.Maps.LocalSearch.LocalLocationFinderResult {
+   public IVectorView<LocalLocation> LocalLocations { get; }
+   public LocalLocationFinderStatus Status { get; }
+ }

+ public enum Windows.Services.Maps.LocalSearch.LocalLocationFinderStatus {
+   Success = 0,
+   UnknownError = 1,
+   InvalidCredentials = 2,
+   InvalidCategory = 3,
+   InvalidSearchTerm = 4,
+   InvalidSearchArea = 5,
+   NetworkFailure = 6,
+   NotSupported = 7,
+ }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Storage.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Storage.winmd

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

 found no differences.

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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.System.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.System.winmd

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

- public enum Windows.System.BatteryStatus;

- public class Windows.System.PowerManager;

- public enum Windows.System.PowerSavingStatus;

- public enum Windows.System.PowerSupplyStatus;

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

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

+ public class Windows.System.Power.PowerManager {
+   public BatteryStatus BatteryStatus { get; }
+   public EnergySaverStatus EnergySaverStatus { get; }
+   public PowerSupplyStatus PowerSupplyStatus { get; }
+   public int RemainingChargePercent { get; }
+   public TimeSpan RemainingDischargeTime { get; }
+   EventHandler<object> BatteryStatusChanged;
+   EventHandler<object> EnergySaverStatusChanged;
+   EventHandler<object> PowerSupplyStatusChanged;
+   EventHandler<object> RemainingChargePercentChanged;
+   EventHandler<object> RemainingDischargeTimeChanged;
+ }

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


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.UI.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.UI.winmd

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

| public class Windows.UI.Composition.CompositionEffect : Windows.UI.Composition.CompositionObject {
+   public IGraphicsEffectSource GetSourceParameter( string result );
+   public void SetSourceParameter( string name, IGraphicsEffectSource source );
-   public IGraphicsEffectInput GetInput( string result );
-   public void SetInput( string name, IGraphicsEffectInput input );
| }

+ public class Windows.UI.Composition.CompositionEffectFactory {
+   public CompositionEffect CreateEffect();
+   public IAsyncAction CompleteLoadAsync();
+ }

- public class Windows.UI.Composition.CompositionEffectNamedInput;

+ public class Windows.UI.Composition.CompositionEffectSourceParameter {
+   public string Name { get; }
+   public CompositionEffectSourceParameter( string name );
+ }

- public class Windows.UI.Composition.CompositionEffectTemplate;

+ public class Windows.UI.Composition.CompositionGraphicsDevice {
+   public CompositionImage CreateImageFromUri( Uri result );
+   public CompositionImage CreateImageFromUri( Uri result, CompositionImageOptions uri );
+ }

- public class Windows.UI.Composition.CompositionGraphicsFactory;

| public class Windows.UI.Composition.CompositionImage : Windows.UI.Composition.CompositionObject {
+   public IAsyncActionWithProgress<CompositionImageProgressStage> CompleteLoadAsync();
-   public IAsyncActionWithProgress<uint> TrackLoadAsync();
| }

+ public enum Windows.UI.Composition.CompositionImageProgressStage {
+   None = 0,
+   HeaderDecoded = 30,
+ }

+ public enum Windows.UI.Composition.CompositionStretch {
+   None = 0,
+   Fill = 1,
+   Uniform = 2,
+   UniformToFill = 3,
+ }

- public enum Windows.UI.Composition.CompositionStretchPolicy;

| public class Windows.UI.Composition.Compositor {
+   public CompositionGraphicsDevice DefaultGraphicsDevice { get; }
-   public CompositionGraphicsFactory DefaultGraphicsFactory { get; }
+   public CompositionEffectFactory CreateEffectFactory( IGraphicsEffect result );
+   public CompositionEffectFactory CreateEffectFactory( IGraphicsEffect result, IIterable<string> graphicsEffect );
+   public CompositionGraphicsDevice CreateGraphicsDevice( IDirect3DDevice factory );
-   public CompositionEffectTemplate CreateEffectTemplate( IGraphicsEffect result );
-   public CompositionEffectTemplate CreateEffectTemplate( IGraphicsEffect result, IIterable<string> effectGraph );
-   public CompositionGraphicsFactory CreateGraphicsFactory( IDirect3DDevice factory );
| }

| public interface Windows.UI.Composition.IFrameworkInput {
-   public void Initialize( CoreInput coreInput );
| }

| public class Windows.UI.Composition.ImageVisual : Windows.UI.Composition.ContainerVisual {
+   public float VerticalAlignmentRatio { get; set; }
+   public CompositionStretch Stretch { get; set; }
+   public ICompositionSurface Image { get; set; }
+   public float HorizontalAlignmentRatio { get; set; }
-   public float VerticalAlignment { get; set; }
-   public CompositionStretchPolicy StretchPolicy { get; set; }
-   public float HorizontalAlignment { get; set; }
-   public ICompositionSurface Content { get; set; }
| }

| public class Windows.UI.Composition.VisualCollection : Windows.UI.Composition.CompositionObject {
+   public void InsertAbove( Visual newChild, Visual sibling );
+   public void InsertBelow( Visual newChild, Visual sibling );
-   public void InsertAboveSibling( Visual newChild, Visual sibling );
-   public void InsertBelowSibling( Visual newChild, Visual sibling );
| }

+ public enum Windows.UI.Core.AppViewBackButtonVisibility {
+   Visible = 0,
+   Collapsed = 1,
+ }

- public class Windows.UI.Core.CoreInput;

| public class Windows.UI.Core.CoreWindow {
| }

- public interface Windows.UI.Core.ICorePointerRedirector;

| public class Windows.UI.Core.SystemNavigationManager {
+   public AppViewBackButtonVisibility AppViewBackButtonVisibility { get; set; }
-   public bool IsShellChromeBackVisible { get; set; }
| }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.UI.Xaml.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.UI.Xaml.winmd

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

| public enum Windows.UI.Xaml.Controls.WebViewPermissionType {
+   Media = 2,
| }

| public class Windows.UI.Xaml.Controls.Maps.MapControl : Windows.UI.Xaml.Controls.Control {
+   public MapInteractionMode TiltInteractionMode { get; set; }
+   public MapInteractionMode RotateInteractionMode { get; set; }
+   public MapPanInteractionMode PanInteractionMode { get; set; }
+   public MapInteractionMode ZoomInteractionMode { get; set; }
+   public DependencyProperty PanInteractionModeProperty { get; }
+   public DependencyProperty RotateInteractionModeProperty { get; }
+   public DependencyProperty TiltInteractionModeProperty { get; }
+   public DependencyProperty ZoomInteractionModeProperty { get; }
-   public bool IsRotateGestureEnabled { get; set; }
-   public MapControlVisibility ZoomControlVisibility { get; set; }
-   public MapControlVisibility CompassControlVisibility { get; set; }
-   public bool IsPanGestureEnabled { get; set; }
-   public MapControlVisibility TiltControlVisibility { get; set; }
-   public bool IsZoomGestureEnabled { get; set; }
-   public bool IsTiltGestureEnabled { get; set; }
-   public DependencyProperty CompassControlVisibilityProperty { get; }
-   public DependencyProperty IsPanGestureEnabledProperty { get; }
-   public DependencyProperty IsRotateGestureEnabledProperty { get; }
-   public DependencyProperty IsTiltGestureEnabledProperty { get; }
-   public DependencyProperty IsZoomGestureEnabledProperty { get; }
-   public DependencyProperty TiltControlVisibilityProperty { get; }
-   public DependencyProperty ZoomControlVisibilityProperty { get; }
+   public void StartContinuousRotate( double rateInDegreesPerSecond );
+   public void StopContinuousRotate();
+   public void StartContinuousTilt( double rateInDegreesPerSecond );
+   public void StopContinuousTilt();
+   public void StartContinuousZoom( double rateOfChangePerSecond );
+   public void StopContinuousZoom();
+   public IAsyncOperation<bool> TryRotateAsync( double returnValue );
+   public IAsyncOperation<bool> TryRotateToAsync( double returnValue );
+   public IAsyncOperation<bool> TryTiltAsync( double returnValue );
+   public IAsyncOperation<bool> TryTiltToAsync( double returnValue );
+   public IAsyncOperation<bool> TryZoomInAsync();
+   public IAsyncOperation<bool> TryZoomOutAsync();
+   public IAsyncOperation<bool> TryZoomToAsync( double returnValue );
-   public IAsyncOperation<bool> RotateAsync( double returnValue );
-   public IAsyncOperation<bool> RotateToAsync( double returnValue );
-   public IAsyncOperation<bool> RotateContinuouslyAsync( double returnValue );
-   public IAsyncOperation<bool> TiltAsync( double returnValue );
-   public IAsyncOperation<bool> TiltToAsync( double returnValue );
-   public IAsyncOperation<bool> TiltContinuouslyAsync( double returnValue );
-   public IAsyncOperation<bool> ZoomInAsync();
-   public IAsyncOperation<bool> ZoomOutAsync();
-   public IAsyncOperation<bool> ZoomToAsync( double returnValue );
-   public IAsyncOperation<bool> ZoomContinuouslyAsync( double returnValue );
| }

- public enum Windows.UI.Xaml.Controls.Maps.MapControlVisibility;

+ public enum Windows.UI.Xaml.Controls.Maps.MapInteractionMode {
+   Auto = 0,
+   Disabled = 1,
+   GestureOnly = 2,
+   ControlOnly = 3,
+   GestureAndControl = 4,
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapPanInteractionMode {
+   Auto = 0,
+   Disabled = 1,
+ }


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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.Web.winmd
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.Web.winmd

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

 found no differences.

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

 new file: \wim\10061x64\Windows\System32\WinMetadata\Windows.World.winmd (NOT EXISTS!)
 old file: \wim\10056x64\Windows\System32\WinMetadata\Windows.World.winmd

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

- public interface Windows.World.ILocatable;

- public interface Windows.World.ILocationFactory;

- public interface Windows.World.ILocationStatics;

- public interface Windows.World.IPositionalLocator;

- public interface Windows.World.IPositionalLocatorDeactivatingEventArgs;

- public enum Windows.World.Locatability;

- public class Windows.World.Location;

- public class Windows.World.LocationStore;

- public class Windows.World.Map;

- public class Windows.World.PositionalLocatorDeactivatingEventArgs;

- public enum Windows.World.PositionalLocatorState;

- public interface Windows.World.Lighting.Prototype.ILightCubeMapFactory;

- public class Windows.World.Lighting.Prototype.Light;

- public class Windows.World.Lighting.Prototype.LightCubeMap;

- public class Windows.World.Lighting.Prototype.LightEventArgs;

- public struct Windows.World.Lighting.Prototype.LightSensorReadingRGB;

- public class Windows.World.Sensors.ActiveChangedEventArgs;

- public class Windows.World.Sensors.AvailableChangedEventArgs;

- public class Windows.World.Sensors.ControllerModeLostEventArgs;

- public class Windows.World.Sensors.CoordinateMapper;

- public class Windows.World.Sensors.CoordinateTransform;

- public class Windows.World.Sensors.EnumerationCompletedEventArgs;

- public class Windows.World.Sensors.FrameArrivedEventArgs;

- public class Windows.World.Sensors.FrameDescriptionChangedEventArgs;

- public class Windows.World.Sensors.FrameReference;

- public enum Windows.World.Sensors.FrameType;

- public interface Windows.World.Sensors.ICoordinateTransform;

- public interface Windows.World.Sensors.IFrameDescription;

- public interface Windows.World.Sensors.IPropertyChangedEventArgs;

- public interface Windows.World.Sensors.ISensorSourceProperty;

- public interface Windows.World.Sensors.ISensorSourcePropertyContinuous;

- public interface Windows.World.Sensors.ISensorSourcePropertyDiscrete;

- public class Windows.World.Sensors.PropertyChangedEventArgs;

- public class Windows.World.Sensors.SensorSource;

- public class Windows.World.Sensors.SensorSourceProperty;

- public class Windows.World.Sensors.SensorSourcePropertyContinuous;

- public class Windows.World.Sensors.SensorSourcePropertyDiscrete;

- public class Windows.World.Sensors.SensorSourceReader;

- public class Windows.World.Sensors.SensorSourceWatcher;

- public enum Windows.World.Sensors.SensorSourceWatcherStatus;

- public class Windows.World.Sensors.SourceAddedEventArgs;

- public class Windows.World.Sensors.SourceRemovedEventArgs;

- public enum Windows.World.Sensors.SourceType;

- public class Windows.World.Sensors.StoppedEventArgs;

- public class Windows.World.Sensors.VideoFrame;

- public class Windows.World.Sensors.VideoFrameDescription;

- public struct Windows.World.Surfaces.BufferDescription;

- public struct Windows.World.Surfaces.BufferRange;

- public interface Windows.World.Surfaces.ISurfaceChangeBatch;

- public class Windows.World.Surfaces.Surface;

- public struct Windows.World.Surfaces.SurfaceChange;

- public class Windows.World.Surfaces.SurfaceChangeBatch;

- public enum Windows.World.Surfaces.SurfaceChangeType;

- public class Windows.World.Surfaces.SurfaceObservation;

- public class Windows.World.Surfaces.SurfaceObserver;

- public struct Windows.World.Surfaces.SurfaceVisibilityChange;

- public enum Windows.World.Surfaces.SurfaceVisibilityChangeType;

- public class Windows.World.Surfaces.VisibleSurfaceChangeBatch;

- public class Windows.World.Surfaces.VisibleSurfaceObserver;

- public struct Windows.World.Surfaces.Prototype.Intersection;

- public class Windows.World.Surfaces.Prototype.PlanarDecomposition;

- public class Windows.World.Surfaces.Prototype.SurfaceAnalyzer;

- public class Windows.World.Surfaces.Prototype.SurfaceObserverPlane;

- public class Windows.World.Surfaces.Prototype.SurfacePlane;

- public class Windows.World.Surfaces.Prototype.SurfaceTriangleSubset;

- public class Windows.World.Surfaces.Prototype.Utilities;