Windows 10 14965 vs. 14946 WinRT API Changes

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

 new files: 14965\Windows\System32\WinMetadata\*
 old files: 14946base\Windows\System32\WinMetadata\*

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

| public class Windows.ApplicationModel.Contacts.ContactGroup {
+   public IAsyncAction DeleteMemberAsync( string value );
+   public IAsyncOperation<IVectorView<ContactGroupMember>> FindMembersByRemoteIdAsync( string operation );
| }

| public class Windows.ApplicationModel.Contacts.ContactStore {
+   public IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsByRemoteIdAsync( string operation );
| }

| public class Windows.ApplicationModel.DataTransfer.DataTransferManager {
+   public static void ShowShareUI( ShareUIOptions shareOptions );
| }

+ public class Windows.ApplicationModel.DataTransfer.ShareUIOptions {
+   public uint ShareTheme { get; set; }
+   public IReference<Point> InvocationPoint { get; set; }
+   public ShareUIOptions();
+ }

| public class Windows.ApplicationModel.Store.LicenseManagement.LicenseManager {
+   public static IAsyncAction RefreshLicensesAsync( LicenseRefreshOption action );
| }

+ public enum Windows.ApplicationModel.Store.LicenseManagement.LicenseRefreshOption {
+   RunningLicenses = 0,
+   AllLicenses = 1,
+ }

| public class Windows.ApplicationModel.UserDataTasks.UserDataTaskList {
+   public UserDataTaskReader GetTaskReader( UserDataTaskQueryOptions value );
| }

+ public enum Windows.ApplicationModel.UserDataTasks.UserDataTaskQueryKind {
+   All = 0,
+   Incomplete = 1,
+   Complete = 2,
+ }

+ public class Windows.ApplicationModel.UserDataTasks.UserDataTaskQueryOptions {
+   public UserDataTaskQuerySortProperty SortProperty { get; set; }
+   public UserDataTaskQueryKind Kind { get; set; }
+   public UserDataTaskQueryOptions();
+ }

+ public enum Windows.ApplicationModel.UserDataTasks.UserDataTaskQuerySortProperty {
+   DueDate = 0,
+ }

+ public class Windows.Gaming.Input.FlightStick {
+   public GameControllerSwitchKind HatSwitchKind { get; }
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public IVectorView<FlightStick> FlightSticks { get; }
+   public GameControllerButtonLabel GetButtonLabel( FlightStickButtons value );
+   public FlightStickReading GetCurrentReading();
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<FlightStick> FlightStickAdded;
+   EventHandler<FlightStick> FlightStickRemoved;
+ }

+ public enum Windows.Gaming.Input.FlightStickButtons {
+   None = 0,
+   FirePrimary = 1,
+   FireSecondary = 2,
+ }

+ public struct Windows.Gaming.Input.FlightStickReading {
+   public ulong Timestamp;
+   public FlightStickButtons Buttons;
+   public GameControllerSwitchPosition HatSwitch;
+   public double Roll;
+   public double Pitch;
+   public double Yaw;
+   public double Throttle;
+ }

+ public enum Windows.Gaming.Input.GameControllerSwitchKind {
+   TwoWay = 0,
+   FourWay = 1,
+   EightWay = 2,
+ }

+ public enum Windows.Gaming.Input.GameControllerSwitchPosition {
+   Center = 0,
+   Up = 1,
+   UpRight = 2,
+   Right = 3,
+   DownRight = 4,
+   Down = 5,
+   DownLeft = 6,
+   Left = 7,
+   UpLeft = 8,
+ }

+ public class Windows.Gaming.Input.RawGameController {
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public int AxisCount { get; }
+   public int ButtonCount { get; }
+   public IVectorView<ForceFeedbackMotor> ForceFeedbackMotors { get; }
+   public ushort HardwareProductId { get; }
+   public ushort HardwareVendorId { get; }
+   public int SwitchCount { get; }
+   public IVectorView<RawGameController> RawGameControllers { get; }
+   public GameControllerButtonLabel GetButtonLabel( int value );
+   public ulong GetCurrentReading( bool[] timestamp, GameControllerSwitchPosition[] buttonArray, double[] switchArray );
+   public GameControllerSwitchKind GetSwitchKind( int value );
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<RawGameController> RawGameControllerAdded;
+   EventHandler<RawGameController> RawGameControllerRemoved;
+ }

+ public class Windows.Gaming.Input.Custom.HidGameControllerProvider {
+   public GameControllerVersionInfo FirmwareVersionInfo { get; }
+   public ushort HardwareProductId { get; }
+   public ushort HardwareVendorId { get; }
+   public GameControllerVersionInfo HardwareVersionInfo { get; }
+   public bool IsConnected { get; }
+   public ushort UsageId { get; }
+   public ushort UsagePage { get; }
+   public void GetFeatureReport( byte reportId, byte[] reportBuffer );
+   public void SendFeatureReport( byte reportId, byte[] reportBuffer );
+   public void SendOutputReport( byte reportId, byte[] reportBuffer );
+ }

+ public interface Windows.Gaming.Input.Custom.IHidGameControllerInputSink {
+   public void OnInputReportReceived( ulong timestamp, byte reportId, byte[] reportBuffer );
+ }

| public class Windows.Networking.NetworkOperators.MobileBroadbandAccount {
*   public Uri AccountExperienceUrl { get; }
| }

| public class Windows.Services.Store.StoreContext {
+   public IAsyncOperation<StoreProductResult> FindStoreProductForPackageAsync( IIterable<string> operation, Package productKinds );
| }

| public class Windows.Services.TargetedContent.TargetedContentObject {
+   public TargetedContentValue PropertyValue { get; }
| }

| public enum Windows.Services.TargetedContent.TargetedContentObjectType {
+   PropertyValue = 2,
| }

| public class Windows.Services.TargetedContent.TargetedContentValue {
+   public IVectorView<TargetedContentAction> Actions { get; }
+   public IVectorView<bool> Booleans { get; }
+   public IVectorView<TargetedContentFile> Files { get; }
+   public IVectorView<TargetedContentImage> Images { get; }
+   public IVectorView<double> Numbers { get; }
+   public IVectorView<string> Strings { get; }
+   public IVectorView<Uri> Uris { get; }
| }

| public enum Windows.Services.TargetedContent.TargetedContentValueType {
+   Strings = 7,
+   Uris = 8,
+   Numbers = 9,
+   Booleans = 10,
+   Files = 11,
+   Images = 12,
+   Actions = 13,
| }

+ public class Windows.System.DispatcherQueue {
+   public DispatcherQueueTimer CreateTimer();
+   public IAsyncAction RunAsync( DispatcherQueueHandler asyncAction );
+   public IAsyncAction RunAsync( DispatcherQueueHandler asyncAction, DispatcherQueuePriority agileCallback );
+   public IAsyncAction RunAsync( DispatcherQueueHandlerAsync asyncAction, DispatcherQueuePriority agileCallback );
+   public void StopProcessEvents();
+   public static IAsyncOperation<DispatcherQueue> CreateDedicatedQueueAsync( DispatcherQueueOptions ppAsyncOperation );
+   public static DispatcherQueue GetForCurrentThread();
+ }

+ public void delegate Windows.System.DispatcherQueueHandler();

+ public IAsyncAction delegate Windows.System.DispatcherQueueHandlerAsync();

+ public class Windows.System.DispatcherQueueOptions {
+   public DispatcherQueueOptions();
+   TypedEventHandler<DispatcherQueue, object> Completed;
+   TypedEventHandler<DispatcherQueue, object> Initialized;
+ }

+ public enum Windows.System.DispatcherQueuePriority {
+   None = 0,
+   Idle = 1,
+   Low = 2,
+   Normal = 3,
+   High = 4,
+ }

+ public class Windows.System.DispatcherQueueTimer {
+   public bool Repeating { get; set; }
+   public TimeSpan Interval { get; set; }
+   public bool IsEnabled { get; }
+   public void Start();
+   public void Stop();
+   TypedEventHandler<DispatcherQueueTimer, object> Tick;
+ }

- public enum Windows.System.Preview.RemoteSessions.BinaryChannelTranportMode;

+ public enum Windows.System.Preview.RemoteSessions.BinaryChannelTransportMode {
+   Datagram = 0,
+   Acknowledged = 1,
+ }

| public class Windows.System.Preview.RemoteSessions.RemoteSession {
+   public IVectorView<RemoteSessionParticipant> Participants { get; }
-   public IVectorView<RemoteSessionParticipant> Participants();
| }

| public class Windows.System.Preview.RemoteSessions.RemoteSessionBinaryChannel {
+   public static RemoteSessionBinaryChannel Create( RemoteSession value, string session, BinaryChannelTransportMode channelName );
| }

| public class Windows.System.Preview.RemoteSessions.RemoteSessionInvitationManager {
+   public static IAsyncOperation<bool> SendInvitationAsync( RemoteSystem value, RemoteSession pInvitee );
| }

| public class Windows.System.RemoteSystems.RemoteSystem {
+   public IAsyncOperation<bool> GetResourceAvailableAsync( string value );
| }

+ public class Windows.System.RemoteSystems.Preview.RemoteSystemResourceQuery {
+   public string RemoteSessionQuery { get; }
+   public string SpatialPerceptionSharingQuery { get; }
+ }

| public class Windows.UI.Input.KnownSimpleHapticsControllerWaveforms {
*   public ushort BuzzContinuous { get; }
*   public ushort Click { get; }
*   public ushort Press { get; }
*   public ushort Release { get; }
*   public ushort RumbleContinuous { get; }
| }

| public class Windows.UI.Input.SimpleHapticsControllerFeedback {
*   public ushort Waveform { get; }
| }

* internal interface Windows.UI.Input.Inking.IInkPresenterProtractorFactory;

| public class Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs {
+   public SpatialPointingPose TryGetPointingPose( SpatialCoordinateSystem pose );
| }

| public class Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs {
+   public SpatialPointingPose TryGetPointingPose( SpatialCoordinateSystem pose );
| }

| public class Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs {
+   public SpatialPointingPose TryGetPointingPose( SpatialCoordinateSystem pose );
| }

+ public enum Windows.UI.Input.Spatial.SpatialInteractionKind {
+   Other = 0,
+   Primary = 1,
+   Secondary = 2,
+   Grasp = 3,
+ }

| public class Windows.UI.Input.Spatial.SpatialInteractionSource {
+   public bool SupportsPointing { get; }
| }

| public class Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs {
+   public SpatialInteractionKind InteractionKind { get; }
+   public SpatialPointingPose TryGetPointingPose( SpatialCoordinateSystem pose );
| }

| public class Windows.UI.Input.Spatial.SpatialInteractionSourceState {
+   public bool IsGrasped { get; }
+   public bool IsPrimaryPressed { get; }
+   public bool IsSecondaryPressed { get; }
+   public SpatialPointingPose TryGetPointingPose( SpatialCoordinateSystem pose );
| }

| public class Windows.UI.Input.Spatial.SpatialPointerPose {
+   public SpatialPointingPose TryGetPointingPose( SpatialInteractionSource pose );
| }

+ public class Windows.UI.Input.Spatial.SpatialPointingPose {
+   public Vector3 ForwardDirection { get; }
+   public Vector3 Position { get; }
+   public Vector3 UpDirection { get; }
+ }

| public class Windows.UI.Input.Spatial.SpatialTappedEventArgs {
+   public SpatialPointingPose TryGetPointingPose( SpatialCoordinateSystem pose );
| }

| public class Windows.UI.Notifications.ToastCollection {
+   public string Id { get; }
-   public string CollectionId { get; }
| }

| public class Windows.UI.Notifications.ToastCollectionManager {
+   public string AppId { get; }
+   public User User { get; }
+   public IAsyncAction RemoveAllToastCollectionsAsync();
-   public IAsyncAction ClearToastCollectionsAsync();
| }

| public class Windows.UI.Notifications.ToastNotificationManager {
+   public ToastNotificationManagerForUser Current { get; }
-   public static IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionAsync( string operation );
-   public static IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionAsync( string operation );
-   public static ToastCollectionManager GetToastCollectionManager();
-   public static ToastCollectionManager GetToastCollectionManager( string result );
| }

| public class Windows.UI.Notifications.ToastNotificationManagerForUser {
+   public IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionIdAsync( string operation );
+   public IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionIdAsync( string operation );
-   public IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionAsync( string operation );
-   public IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionAsync( string operation );
| }

| public class Windows.UI.Xaml.Automation.Peers.MapControlAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+   public bool CanRotate { get; }
+   public bool CanMove { get; }
+   public bool CanResize { get; }
+   public double ZoomLevel { get; }
+   public bool CanZoom { get; }
+   public double MaxZoom { get; }
+   public double MinZoom { get; }
+   public void Zoom( double zoom );
+   public void ZoomByUnit( ZoomUnit zoomUnit );
+   public void Move( double x, double y );
+   public void Resize( double width, double height );
+   public void Rotate( double degrees );
| }

| public class Windows.UI.Xaml.Documents.Hyperlink : Windows.UI.Xaml.Documents.Span {
+   public FocusState FocusState { get; }
+   public DependencyProperty FocusStateProperty { get; }
| }

+ public class Windows.UI.Xaml.Markup.XamlMarkupHelper {
+   public static void UnloadObject( DependencyObject element );
+ }