Windows 10 SDK Preview Build 17046 now available

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17046 or greater). The Preview SDK Build 17046 contains bug fixes and under development changes to the API surface area.

The Preview SDK can be downloaded from developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

Things to note:

  • This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 Creators build or earlier to the store.
  • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.

Known Issues

  • “All tests run with Windows App Certification Kit will fail. During installation, please uncheck Windows App Certification Kit”

What’s New:

  • C++/WinRT Now Available:
    The C++/WinRT headers and cppwinrt compiler (cppwinrt.exe) are now included in the Windows SDK. The compiler comes in handy if you need to consume a third-party WinRT component or if you need to author your own WinRT components with C++/WinRT. The easiest way to get working with it after installing the Windows Insider Preview SDK is to start the Visual Studio Developer Command Prompt and run the compiler in that environment. Authoring support is currently experimental and subject to change. Stay tuned as we will publish more detailed instructions on how to use the compiler in the coming week.The ModernCPP blog has a deeper dive into the CppWinRT compiler. Please give us feedback by creating an issue at: https://github.com/microsoft/cppwinrt.

Breaking Changes

  • New MIDL key words.

As a part of the “modernizing IDL” effort, several new keywords are added to the midlrt tool. These new keywords will cause build breaks if they are encountered in IDL files.

The new keywords are:

  • event
  • set
  • get
  • partial
  • unsealed
  • overridable
  • protected
  • importwinmd

If any of these keywords is used as an identifier, it will generate a build failure indicating a syntax error.

The error will be similar to:
1 >d:\os\src\onecore\com\combase\unittest\astatestservers\testserver6\idl\remreleasetest.idl(12) : error MIDL2025 : [msg]syntax error [context]: expecting a declarator or * near “)”

To fix this, modify the identifier in error to an “@” prefix in front of the identifier. That will cause MIDL to treat the offending element as an identifier instead of a keyword.

API Updates and Additions

When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.

The following APIs have been added to the platform since the release of 16299.



namespace Windows.ApplicationModel {
  public enum StartupTaskState {
    EnabledByPolicy = 4,
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class MobileBroadbandPcoDataChangeTrigger : IBackgroundTrigger
  public sealed class TetheringEntitlementCheckTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
  public enum PhoneCallMedia {
    AudioAndRealTimeText = 2,
  }
  public sealed class VoipCallCoordinator {
    VoipPhoneCall RequestNewAppInitiatedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
    VoipPhoneCall RequestNewIncomingCall(string context, string contactName, string contactNumber, Uri contactImage, string serviceName, Uri brandingImage, string callDetails, Uri ringtone, VoipPhoneCallMedia media, TimeSpan ringTimeout, string contactRemoteId);
  }
  public sealed class VoipPhoneCall {
    void NotifyCallAccepted(VoipPhoneCallMedia media);
  }
}
namespace Windows.ApplicationModel.Chat {
  public sealed class RcsManagerChangedEventArgs
  public enum RcsManagerChangeType
  public sealed class RcsNotificationManager
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallManager {
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesAsync(string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync(User user, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesAsync(string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync(User user, string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync(string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync(User user, string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
  }
  public sealed class AppInstallOptions
  public sealed class AppInstallStatus {
    bool IsStaged { get; }
  }
  public sealed class AppUpdateOptions
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity {
    public UserActivity(string activityId);
  }
  public sealed class UserActivityChannel {
    public static void DisableAutoSessionCreation();
  }
  public sealed class UserActivityVisualElements {
    string AttributionDisplayText { get; set; }
  }
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScannerReport {
    public BarcodeScannerReport(uint scanDataType, IBuffer scanData, IBuffer scanDataLabel);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    bool IsVideoPreviewShownOnEnable { get; set; }
    void HideVideoPreview();
    IAsyncOperation<bool> ShowVideoPreviewAsync();
  }
  public sealed class UnifiedPosErrorData {
    public UnifiedPosErrorData(string message, UnifiedPosErrorSeverity severity, UnifiedPosErrorReason reason, uint extendedReason);
  }
}
namespace Windows.Devices.PointOfService.Provider {
  public sealed class BarcodeScannerDisableScannerRequest
  public sealed class BarcodeScannerDisableScannerRequestEventArgs
  public sealed class BarcodeScannerEnableScannerRequest
  public sealed class BarcodeScannerEnableScannerRequestEventArgs
  public sealed class BarcodeScannerGetSymbologyAttributesRequest
  public sealed class BarcodeScannerGetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerHideVideoPreviewRequest
  public sealed class BarcodeScannerHideVideoPreviewRequestEventArgs
  public sealed class BarcodeScannerProviderConnection : IClosable
  public sealed class BarcodeScannerProviderTriggerDetails
  public sealed class BarcodeScannerSetActiveSymbologiesRequest
  public sealed class BarcodeScannerSetActiveSymbologiesRequestEventArgs
  public sealed class BarcodeScannerSetSymbologyAttributesRequest
  public sealed class BarcodeScannerSetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerStartSoftwareTriggerRequest
  public sealed class BarcodeScannerStartSoftwareTriggerRequestEventArgs
  public sealed class BarcodeScannerStopSoftwareTriggerRequest
  public sealed class BarcodeScannerStopSoftwareTriggerRequestEventArgs
  public enum BarcodeScannerTriggerState
  public sealed class BarcodeSymbologyAttributesBuilder
}
namespace Windows.Globalization {
  public static class ApplicationLanguages {
    public static IVectorView<string> GetLanguagesForUser(User user);
  }
  public sealed class Language {
    LanguageLayoutDirection LayoutDirection { get; }
  }
  public enum LanguageLayoutDirection
}
namespace Windows.Graphics.Imaging {
  public enum BitmapPixelFormat {
    P010 = 104,
  }
}
namespace Windows.Management.Deployment {
  public sealed class PackageManager {
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris, IIterable<Uri> packageUrisToInstall);
  }
}
namespace Windows.Media.Audio {
  public sealed class AudioGraph : IClosable {
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource);
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource, AudioNodeEmitter emitter);
  }
  public sealed class AudioGraphSettings {
    double MaxPlaybackSpeedFactor { get; set; }
  }
  public sealed class AudioStateMonitor
  public sealed class CreateMediaSourceAudioInputNodeResult
  public sealed class MediaSourceAudioInputNode : IAudioInputNode, IAudioInputNode2, IAudioNode, IClosable
  public enum MediaSourceAudioInputNodeCreationStatus
}
namespace Windows.Media.Capture {
  public sealed class CapturedFrame : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType {
    BitmapPropertySet BitmapProperties { get; }
    CapturedFrameControlValues ControlValues { get; }
  }
  public enum KnownVideoProfile {
    HdrWithWcgPhoto = 8,
    HdrWithWcgVideo = 7,
    HighFrameRate = 5,
    VariablePhotoSequence = 6,
    VideoHdr8 = 9,
  }
  public sealed class MediaCaptureSettings {
    IDirect3DDevice Direct3D11Device { get; }
  }
  public sealed class MediaCaptureVideoProfile {
    IVectorView<MediaFrameSourceInfo> FrameSourceInfos { get; }
    IMapView<Guid, object> Properties { get; }
  }
  public sealed class MediaCaptureVideoProfileMediaDescription {
    IMapView<Guid, object> Properties { get; }
    string Subtype { get; }
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class AudioMediaFrame
  public sealed class MediaFrameFormat {
    AudioEncodingProperties AudioEncodingProperties { get; }
  }
  public sealed class MediaFrameReference : IClosable {
    AudioMediaFrame AudioMediaFrame { get; }
  }
  public sealed class MediaFrameSourceController {
    AudioDeviceController AudioDeviceController { get; }
  }
  public sealed class MediaFrameSourceInfo {
    string ProfileId { get; }
    IVectorView<MediaCaptureVideoProfileMediaDescription> VideoProfileMediaDescription { get; }
  }
  public enum MediaFrameSourceKind {
    Audio = 4,
    Image = 5,
  }
}
namespace Windows.Media.Core {
  public sealed class MediaBindingEventArgs {
    void SetDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    DownloadOperation DownloadOperation { get; }
    public static MediaSource CreateFromDownloadOperation(DownloadOperation downloadOperation);
  }
}
namespace Windows.Media.Devices {
  public sealed class VideoDeviceController : IMediaDeviceController {
    VideoTemporalDenoisingControl VideoTemporalDenoisingControl { get; }
  }
  public sealed class VideoTemporalDenoisingControl
  public enum VideoTemporalDenoisingMode
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp {
    IAsyncOperation<string> GetUniqueDeviceNameAsync();
  }
}
namespace Windows.Media.MediaProperties {
  public static class MediaEncodingSubtypes {
    public static string P010 { get; }
  }
  public enum MediaPixelFormat {
    P010 = 2,
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSession {
    MediaRotation PlaybackRotation { get; set; }
    MediaPlaybackSessionOutputDegradationPolicyState GetOutputDegradationPolicyState();
  }
  public sealed class MediaPlaybackSessionOutputDegradationPolicyState
  public enum MediaPlaybackSessionVideoConstrictionReason
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
  public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class CellularApnContext {
    string ProfileName { get; set; }
  }
  public sealed class ConnectionProfileFilter {
    IReference<Guid> PurposeGuid { get; set; }
  }
  public sealed class WwanConnectionProfileDetails {
    WwanNetworkIPKind IPKind { get; }
    IVectorView<Guid> PurposeGuids { get; }
  }
  public enum WwanNetworkIPKind
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAntennaSar {
    public MobileBroadbandAntennaSar(int antennaIndex, int sarBackoffIndex);
  }
  public sealed class MobileBroadbandModem {
    IAsyncOperation<MobileBroadbandPco> TryGetPcoAsync();
  }
  public sealed class MobileBroadbandModemIsolation
  public sealed class MobileBroadbandPco
  public sealed class MobileBroadbandPcoDataChangeTriggerDetails
  public sealed class TetheringEntitlementCheckTriggerDetails
}
namespace Windows.Networking.Sockets {
  public sealed class ServerMessageWebSocket : IClosable
  public sealed class ServerMessageWebSocketControl
  public sealed class ServerMessageWebSocketInformation
  public sealed class ServerStreamWebSocket : IClosable
  public sealed class ServerStreamWebSocketInformation
}
namespace Windows.Networking.Vpn {
  public sealed class VpnNativeProfile : IVpnProfile {
    string IDi { get; set; }
    VpnPayloadIdType IdiType { get; set; }
    string IDr { get; set; }
    VpnPayloadIdType IdrType { get; set; }
    bool IsImsConfig { get; set; }
    string PCscf { get; }
  }
  public enum VpnPayloadIdType
}
namespace Windows.Security.Authentication.Identity.Provider {
  public enum SecondaryAuthenticationFactorAuthenticationMessage {
    CanceledByUser = 22,
    CenterHand = 23,
    ConnectionRequired = 20,
    DeviceUnavaliable = 28,
    MoveHandCloser = 24,
    MoveHandFarther = 25,
    PlaceHandAbove = 26,
    RecognitionFailed = 27,
    TimeLimitExceeded = 21,
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRouteDrivingOptions {
    IReference<DateTime> DepartureTime { get; set; }
  }
  public sealed class PlaceInfo {
    public static PlaceInfo CreateFromAddress(string displayAddress);
    public static PlaceInfo CreateFromAddress(string displayAddress, string displayName);
  }
}
namespace Windows.Services.Store {
  public sealed class StoreCanAcquireLicenseResult
  public enum StoreCanLicenseStatus
  public sealed class StoreContext {
    bool CanSilentlyDownloadStorePackageUpdates { get; }
    IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseForOptionalPackageAsync(Package optionalPackage);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadAndInstallStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
  }
}
namespace Windows.Storage.Provider {
  public interface IStorageProviderUriSource
  public enum StorageProviderResolveContentUriResult
}
namespace Windows.System {
  public sealed class AppActivationResult
  public sealed class AppDiagnosticInfo {
    IAsyncOperation<AppActivationResult> ActivateAsync();
  }
  public sealed class AppResourceGroupInfo {
    IAsyncOperation<bool> TryResumeAsync();
    IAsyncOperation<bool> TrySuspendAsync();
    IAsyncOperation<bool> TryTerminateAsync();
  }
  public sealed class User {
    public static User GetDefault();
  }
  public enum UserType {
    SystemManaged = 4,
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticInvoker {
    IAsyncOperationWithProgress<DiagnosticActionResult, DiagnosticActionState> RunDiagnosticActionFromStringAsync(string context);
  }
}
namespace Windows.System.Diagnostics.DevicePortal {
  public sealed class DevicePortalConnection {
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol, uint outboundBufferSizeInBytes, uint maxMessageSize, MessageWebSocketReceiveMode receiveMode);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request, string protocol, uint outboundBufferSizeInBytes, bool noDelay);
  }
  public sealed class DevicePortalConnectionRequestReceivedEventArgs {
    bool IsWebSocketUpgradeRequest { get; }
    IVectorView<string> WebSocketProtocolsRequested { get; }
    Deferral GetDeferral();
  }
}
namespace Windows.System.RemoteSystems {
  public static class KnownRemoteSystemCapabilities {
    public static string NearShare { get; }
  }
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static GlobalizationPreferencesForUser GetForUser(User user);
  }
  public sealed class GlobalizationPreferencesForUser
}
namespace Windows.UI.ApplicationSettings {
  public sealed class AccountsSettingsPane {
    public static IAsyncAction ShowAddAccountForUserAsync(User user);
    public static IAsyncAction ShowManageAccountsForUserAsync(User user);
  }
  public sealed class AccountsSettingsPaneCommandsRequestedEventArgs {
    User User { get; }
  }
}
namespace Windows.UI.Composition {
  public sealed class BounceScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class BounceVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class BounceVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public class CompositionLight : CompositionObject {
    bool IsEnabled { get; set; }
  }
  public sealed class Compositor : IClosable {
    string Comment { get; set; }
    BounceScalarNaturalMotionAnimation CreateBounceScalarAnimation();
    BounceVector2NaturalMotionAnimation CreateBounceVector2Animation();
    BounceVector3NaturalMotionAnimation CreateBounceVector3Animation();
  }
  public sealed class PointLight : CompositionLight {
    Vector2 AttenuationCutoff { get; set; }
  }
  public sealed class SpotLight : CompositionLight {
    Vector2 AttenuationCutoff { get; set; }
  }
}
namespace Windows.UI.Composition.Core {
  public sealed class CompositorController : IClosable
}
namespace Windows.UI.Composition.Desktop {
  public sealed class HwndTarget : CompositionTarget
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.UI.Xaml {
  public sealed class BringIntoViewOptions {
    double HorizontalAlignmentRatio { get; set; }
    double HorizontalOffset { get; set; }
    double VerticalAlignmentRatio { get; set; }
    double VerticalOffset { get; set; }
  }
  public sealed class BringIntoViewRequestedEventArgs : RoutedEventArgs
  public sealed class EffectiveViewportChangedEventArgs
  public enum FocusVisualKind {
    Reveal = 2,
  }
  public class FrameworkElement : UIElement {
    event TypedEventHandler<FrameworkElement, EffectiveViewportChangedEventArgs> EffectiveViewportChanged;
    void InvalidateViewport();
    virtual bool IsViewport();
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent BringIntoViewRequestedEvent { get; }
    public static RoutedEvent ContextRequestedEvent { get; }
    KeyboardAcceleratorPlacementMode KeyboardAcceleratorPlacementMode { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementModeProperty { get; }
    DependencyObject KeyboardAcceleratorToolTipTarget { get; set; }
    public static DependencyProperty KeyboardAcceleratorToolTipTargetProperty { get; }
    DependencyObject KeyTipTarget { get; set; }
    public static DependencyProperty KeyTipTargetProperty { get; }
    event TypedEventHandler<UIElement, BringIntoViewRequestedEventArgs> BringIntoViewRequested;
    virtual void OnBringIntoViewRequested(BringIntoViewRequestedEventArgs e);
    virtual void OnKeyboardAcceleratorInvoked(KeyboardAcceleratorInvokedEventArgs args);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public sealed class AutoSuggestBoxAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider {
    void Invoke();
  }
  public class CalendarDatePickerAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider, IValueProvider
}
namespace Windows.UI.Xaml.Controls {
  public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorText { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextProperty { get; }
    AppBarButtonTemplateSettings TemplateSettings { get; }
  }
  public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorText { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextProperty { get; }
    AppBarToggleButtonTemplateSettings TemplateSettings { get; }
  }
  public class MenuFlyoutItem : MenuFlyoutItemBase {
    string KeyboardAcceleratorText { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextProperty { get; }
    MenuFlyoutItemTemplateSettings TemplateSettings { get; }
  }
  public class NavigationView : ContentControl {
    string PaneTitle { get; set; }
    public static DependencyProperty PaneTitleProperty { get; }
    event TypedEventHandler<NavigationView, object> PaneClosed;
    event TypedEventHandler<NavigationView, NavigationViewPaneClosingEventArgs> PaneClosing;
    event TypedEventHandler<NavigationView, object> PaneOpened;
    event TypedEventHandler<NavigationView, object> PaneOpening;
  }
  public sealed class NavigationViewPaneClosingEventArgs
  public sealed class ScrollViewer : ContentControl {
    bool IsResponsiveToOcclusions { get; set; }
    public static DependencyProperty IsResponsiveToOcclusionsProperty { get; }
  }
  public enum WebViewPermissionType {
    Screen = 5,
  }
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    string Region { get; set; }
    public static DependencyProperty RegionProperty { get; }
  }
  public class MapElement : DependencyObject {
    bool IsEnabled { get; set; }
    public static DependencyProperty IsEnabledProperty { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public sealed class AppBarButtonTemplateSettings : DependencyObject
  public sealed class AppBarToggleButtonTemplateSettings : DependencyObject
  public class ListViewItemPresenter : ContentPresenter {
    bool DisableTilt { get; set; }
    public static DependencyProperty DisableTiltProperty { get; }
  }
  public sealed class MenuFlyoutItemTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Input {
  public sealed class GettingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
  public sealed class KeyboardAcceleratorInvokedEventArgs {
    KeyboardAccelerator KeyboardAccelerator { get; }
  }
  public enum KeyboardAcceleratorPlacementMode
  public sealed class LosingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
}