Tag Archives: preview sdk

Windows 10 SDK Preview Build 16232 Released

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 16232 or greater). The Preview SDK Build 16232 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 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

  • Designer fails to render: When viewing the XAML in the Designer Window in Visual Studio, the controls fail to render. This can be resolved by using Visual Studio 2017.3 Preview.
  • Compilation fails on non-Windows 10 platforms
    When building apps on previous platforms, you may get a build error:

C:program files (x86)Windows Kits10bin10.0.16232.0x86genxbf.dll:C:program files (x860Windows
Kits10bin10.0.16232.0x86genxbf.dll(0,0): Error WMC0621: Cannot resolve ‘GenXbf.dll’ under path ‘C:program files (x860Windows
Kits10bin10.0.16232.0x86genxbf.dll’. Please install the latest version of the Windows 10 Software Development Kit.
Process ‘msbuild.exe’ exited with code ‘1’.

This will occur if the minimum target platform version is set to 10.0.16225.0. To work around this, right click on your project file and choose properties or open your project file in your favorite editor, and change the version to a previous released SDK. For example:


<WindowsTargetPlatformMinVersion>10.0.10586.0</WindowsTargetPlatformMinVersion>

  • WRL projects fail to compile with MIDLRT error: When building my WRL project that contains a WinRT Component, the project no longer compiles. I get the following errors:

midlrt : command line error MIDL1012: [msg]argument illegal for switch / [context]ns_prefix
midlrt : command line error MIDL1000: [msg]missing source-file name

To work around this temporarily, you will need to use the previous version of the MidlRT.exe tool. You can do this by changing your Target Platform Version to a currently installed previous SDK.


<WindowsTargetPlatformVersion>10.0.15063.0</WindowsTargetPlatformVersion>

Breaking Changes

  • ecmangen.exe removal from the SDK: Ecmangen.exe will no longer ship with the Windows SDK. Developers who rely on ecmangen for event manifest creation are advised to install the Windows Creators Edition of the SDK to obtain the file. Developers may also use notepad or other XML editor of choice for manifest creation. A schema file is available on MSDN to aid in manifest creation, for tools that support it.

API Differences from Windows 10 Creators Update

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.

API Additions


namespace Windows.ApplicationModel.Calls {
  public sealed class VoipCallCoordinator {
    VoipPhoneCall SetupNewAcceptedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
  }
  public sealed class VoipPhoneCall {
    void TryShowAppUI();
  }
}
 
namespace Windows.ApplicationModel {
  public enum StartupTaskState {
    DisabledByPolicy = 3,
  }
}
 
namespace Windows.Devices.SmartCards {
  public sealed class SmartCardCryptogramGenerator {
    public static bool IsSupported();
  }
  public enum SmartCardCryptogramGeneratorOperationStatus {
    NotSupported = 13,
  }
  public sealed class SmartCardEmulator {
    public static bool IsSupported();
  }
}
namespace Windows.ApplicationModel {
  public static class DesignMode {
    public static bool DesignMode2Enabled { get; }
  }
  public sealed class PackageCatalog {
    IAsyncOperation<PackageCatalogRemoveOptionalPackagesResult> RemoveOptionalPackagesAsync(IIterable<string> optionalPackageFamilyNames);
  }
  public sealed class PackageCatalogRemoveOptionalPackagesResult
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    CommandLineLaunch = 1021,
    GameUIProvider = 1019,
    PrintWorkflowForegroundTask = 1018,
    StartupTask = 1020,
  }
  public sealed class CommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class CommandLineActivationOperation
  public interface ICommandLineActivatedEventArgs : IActivatedEventArgs
  public interface IStartupTaskActivatedEventArgs : IActivatedEventArgs
  public sealed class StartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.ApplicationModel.Appointments {
  public sealed class AppointmentStore {
    AppointmentStoreChangeTracker GetChangeTracker(string identity);
  }
  public sealed class AppointmentStoreChangeTracker {
    bool IsTracking { get; }
  }
}
namespace Windows.ApplicationModel.AppService {
  public sealed class AppServiceTriggerDetails {
    IAsyncOperation<bool> CheckCallerForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class GeovisitTrigger : IBackgroundTrigger
  public sealed class PaymentAppCanMakePaymentTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactChangeTracker {
    bool IsTracking { get; }
  }
  public sealed class ContactList {
    ContactListLimitedWriteOperations LimitedWriteOperations { get; }
    ContactChangeTracker GetChangeTracker(string identity);
  }
  public sealed class ContactListLimitedWriteOperations
  public enum ContactListOtherAppWriteAccess {
    Limited = 2,
  }
  public sealed class ContactStore {
    ContactChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Contacts.DataProvider {
  public sealed class ContactDataProviderConnection {
    event TypedEventHandler<ContactDataProviderConnection, ContactListCreateOrUpdateContactRequestEventArgs> CreateOrUpdateContactRequested;
    event TypedEventHandler<ContactDataProviderConnection, ContactListDeleteContactRequestEventArgs> DeleteContactRequested;
  }
  public sealed class ContactListCreateOrUpdateContactRequest
  public sealed class ContactListCreateOrUpdateContactRequestEventArgs
  public sealed class ContactListDeleteContactRequest
  public sealed class ContactListDeleteContactRequestEventArgs
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    string AppUserModelId { get; }
  }
  public enum AppRestartFailureReason
  public static class CoreApplication {
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync(string launchArguments);
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class CoreApplicationView {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataTransferManager {
    public static void ShowShareUI(ShareUIOptions options);
  }
  public sealed class ShareUIOptions
  public enum ShareUITheme
}
namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
  public sealed class ShareOperation {
    IVectorView<Contact> Contacts { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMailbox {
    EmailMailboxChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Payments {
  public sealed class PaymentCanMakePaymentResult
  public enum PaymentCanMakePaymentResultStatus
  public sealed class PaymentMediator {
    IAsyncOperation<PaymentCanMakePaymentResult> CanMakePaymentAsync(PaymentRequest paymentRequest);
  }
  public sealed class PaymentRequest {
    public PaymentRequest(PaymentDetails details, IIterable<PaymentMethodData> methodData, PaymentMerchantInfo merchantInfo, PaymentOptions options, string id);
    string Id { get; }
  }
}
namespace Windows.ApplicationModel.Payments.Provider {
  public sealed class PaymentAppCanMakePaymentTriggerDetails
}
namespace Windows.ApplicationModel.UserActivities {
  public interface IUserActivityContentInfo
  public sealed class UserActivity
  public sealed class UserActivityAttribution
  public sealed class UserActivityChannel
  public sealed class UserActivityContentInfo : IUserActivityContentInfo
  public sealed class UserActivitySession : IClosable
  public enum UserActivityState
  public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
  public static class CoreUserActivityManager
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
  public sealed class BluetoothDeviceId {
    public static BluetoothDeviceId FromId(string deviceId);
  }
  public sealed class BluetoothLEDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattClientNotificationResult {
    ushort BytesSent { get; }
  }
}
namespace Windows.Devices.Geolocation {
  public sealed class Geovisit
  public sealed class GeovisitMonitor
  public sealed class GeovisitStateChangedEventArgs
  public sealed class GeovisitTriggerDetails
  public enum VisitMonitoringScope
  public enum VisitStateChange
}
namespace Windows.Devices.PointOfService {
  public sealed class ClaimedLineDisplay : IClosable {
    LineDisplayCustomGlyphs CustomGlyphs { get; }
    Size MaxBitmapSizeInPixels { get; }
    IVectorView<int> SupportedCharacterSets { get; }
    IVectorView<Size> SupportedScreenSizesInCharacters { get; }
    event TypedEventHandler<ClaimedLineDisplay, LineDisplayStatusUpdatedEventArgs> StatusUpdated;
    IAsyncOperation<string> CheckHealthAsync(UnifiedPosHealthCheckLevel level);
    IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
    LineDisplayAttributes GetAttributes();
    IAsyncOperation<string> GetStatisticsAsync(IIterable<string> statisticsCategories);
    IAsyncOperation<bool> TryClearDescriptorsAsync();
    IAsyncOperation<LineDisplayWindow> TryCreateWindowAsync(Rect viewport, Size windowSize);
    IAsyncOperation<bool> TrySetDescriptorAsync(uint descriptor, LineDisplayDescriptorState descriptorState);
    IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap);
    IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation<bool> TryUpdateAttributesAsync(LineDisplayAttributes attributes);
  }
  public sealed class LineDisplay : IClosable {
    public static LineDisplayStatisticsCategorySelector StatisticsCategorySelector { get; }
    IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
  }
  public sealed class LineDisplayAttributes
  public sealed class LineDisplayCursor
  public sealed class LineDisplayCursorAttributes
  public enum LineDisplayCursorType
  public sealed class LineDisplayCustomGlyphs
  public enum LineDisplayDescriptorState
  public enum LineDisplayHorizontalAlignment
  public sealed class LineDisplayMarquee
  public enum LineDisplayMarqueeFormat
  public enum LineDisplayPowerStatus
  public sealed class LineDisplayStatisticsCategorySelector
  public sealed class LineDisplayStatusUpdatedEventArgs
  public sealed class LineDisplayStoredBitmap
  public enum LineDisplayVerticalAlignment
  public sealed class LineDisplayWindow : IClosable {
    LineDisplayCursor Cursor { get; }
    LineDisplayMarquee Marquee { get; }
    IAsyncOperation<uint> ReadCharacterAtCursorAsync();
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels, int widthInPixels);
    IAsyncOperation<bool> TryDisplayStoredBitmapAtCursorAsync(LineDisplayStoredBitmap bitmap);
  }
}
namespace Windows.Devices.Sensors {
  public sealed class Accelerometer {
    public static IAsyncOperation<Accelerometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector(AccelerometerReadingType readingType);
  }
  public sealed class AccelerometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Altimeter {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class AltimeterReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Barometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Barometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class BarometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Compass {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Compass> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class CompassReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Gyrometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Gyrometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class GyrometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Inclinometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Inclinometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
  }
  public sealed class InclinometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class LightSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<LightSensor> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class LightSensorReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Magnetometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Magnetometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class MagnetometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class OrientationSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<OrientationSensor> FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
    public static string GetDeviceSelector(SensorReadingType readingType, SensorOptimizationGoal optimizationGoal);
  }
  public sealed class OrientationSensorReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
}
namespace Windows.Devices.Sensors.Custom {
  public sealed class CustomSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class CustomSensorReading {
    IReference<TimeSpan> PerformanceCount { get; }
  }
}
namespace Windows.Devices.WiFi {
  public sealed class WiFiAdapter {
    IAsyncOperation<WiFiConnectionResult> ConnectAsync(WiFiAvailableNetwork availableNetwork, WiFiReconnectionKind reconnectionKind, PasswordCredential passwordCredential, string ssid, WiFiConnectionMethod connectionMethod);
    IAsyncOperation<WiFiWpsConfigurationResult> GetWpsConfigurationAsync(WiFiAvailableNetwork availableNetwork);
  }
  public enum WiFiConnectionMethod
  public sealed class WiFiWpsConfigurationResult
  public enum WiFiWpsConfigurationStatus
  public enum WiFiWpsKind
}
namespace Windows.Gaming.Input {
  public sealed class RawGameController : IGameController, IGameControllerBatteryInfo {
    string DisplayName { get; }
    string NonRoamableId { get; }
    IVectorView<SimpleHapticsController> SimpleHapticsControllers { get; }
  }
}
namespace Windows.Gaming.UI {
  public sealed class GameMonitor
  public enum GameMonitoringPermission
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool IsPrimaryLayerEnabled { get; set; }
    uint MaxQuadLayerCount { get; }
    IVector<HolographicQuadLayer> QuadLayers { get; }
  }
  public sealed class HolographicCameraRenderingParameters {
    bool IsContentProtectionEnabled { get; set; }
  }
  public sealed class HolographicDisplay {
    double RefreshRate { get; }
  }
  public sealed class HolographicFrame {
    HolographicQuadLayerUpdateParameters GetQuadLayerUpdateParameters(HolographicQuadLayer layer);
  }
  public sealed class HolographicQuadLayer : IClosable
  public sealed class HolographicQuadLayerUpdateParameters
  public sealed class HolographicSpace {
    public static bool IsConfigured { get; }
  }
}
namespace Windows.Graphics.Printing.PrintTicket {
  public sealed class PrintTicketCapabilities
  public sealed class PrintTicketFeature
  public enum PrintTicketFeatureSelectionType
  public sealed class PrintTicketOption
  public enum PrintTicketParameterDataType
  public sealed class PrintTicketParameterDefinition
  public sealed class PrintTicketParameterInitializer
  public sealed class PrintTicketValue
  public enum PrintTicketValueType
  public sealed class WorkflowPrintTicket
  public sealed class WorkflowPrintTicketValidationResult
}
namespace Windows.Graphics.Printing.Workflow {
  public sealed class PrintWorkflowBackgroundSession
  public sealed class PrintWorkflowBackgroundSetupRequestedEventArgs
  public sealed class PrintWorkflowConfiguration
  public sealed class PrintWorkflowForegroundSession
  public sealed class PrintWorkflowForegroundSetupRequestedEventArgs
  public sealed class PrintWorkflowObjectModelSourceFileContent
  public sealed class PrintWorkflowObjectModelTargetPackage
  public enum PrintWorkflowSessionStatus
  public sealed class PrintWorkflowSourceContent
  public sealed class PrintWorkflowSpoolStreamContent
  public sealed class PrintWorkflowStreamTarget
  public sealed class PrintWorkflowSubmittedEventArgs
  public sealed class PrintWorkflowSubmittedOperation
  public enum PrintWorkflowSubmittedStatus
  public sealed class PrintWorkflowTarget
  public sealed class PrintWorkflowTriggerDetails
  public sealed class PrintWorkflowUIActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser
  public sealed class PrintWorkflowXpsDataAvailableEventArgs
}
namespace Windows.Management.Deployment {
  public enum AddPackageByAppInstallerOptions : uint
  public sealed class PackageManager {
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall, IIterable<Uri> relatedPackageUris);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> ProvisionPackageForAllUsersAsync(string packageFamilyName);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall, IIterable<Uri> relatedPackageUris);
  }
}
namespace Windows.Media.Capture {
  public sealed class AppCapture {
    public static IAsyncAction SetAllowedAsync(bool allowed);
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class MediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
  public enum MediaFrameReaderAcquisitionMode
  public sealed class MultiSourceMediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
  public interface IMediaStreamDescriptor2 : IMediaStreamDescriptor
  public sealed class InitializeMediaStreamSourceRequestedEventArgs
  public static class LowLightFusion
  public sealed class LowLightFusionResult : IClosable
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    public static MediaSource CreateFromMediaFrameSource(MediaFrameSource frameSource);
  }
  public sealed class MediaSourceAppServiceConnection
  public sealed class MediaStreamSource : IMediaSource {
    bool IsLive { get; set; }
  }
  public sealed class MseStreamSource : IMediaSource {
    IReference<MseTimeRange> LiveSeekableRange { get; set; }
  }
  public sealed class SceneAnalysisEffectFrame : IClosable, IMediaFrame {
    SceneAnalysisRecommendation AnalysisRecommendation { get; }
  }
  public enum SceneAnalysisRecommendation
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp
}
namespace Windows.Media.MediaProperties {
  public sealed class MediaEncodingProfile {
    IVector<AudioStreamDescriptor> GetAudioTracks();
    IVector<VideoStreamDescriptor> GetVideoTracks();
    void SetAudioTracks(IIterable<AudioStreamDescriptor> value);
    void SetVideoTracks(IIterable<VideoStreamDescriptor> value);
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSessionBufferingStartedEventArgs
  public sealed class MediaPlayer : IClosable {
    event TypedEventHandler<MediaPlayer, object> SubtitleFrameChanged;
    bool RenderSubtitlesToSurface(IDirect3DSurface destination);
    bool RenderSubtitlesToSurface(IDirect3DSurface destination, Rect targetRectangle);
  }
}
namespace Windows.Media.Protection.PlayReady {
  public enum PlayReadyEncryptionAlgorithm {
    Aes128Cbc = 5,
    Unspecified = 65535,
  }
  public enum PlayReadyHardwareDRMFeatures {
    Aes128Cbc = 3,
  }
}
namespace Windows.Media.SpeechRecognition {
  public sealed class SpeechRecognizer : IClosable {
    public static IAsyncOperation<bool> TrySetSystemSpeechLanguageAsync(Language speechLanguage);
  }
}
namespace Windows.Media.SpeechSynthesis {
  public sealed class SpeechSynthesizer : IClosable {
    public static IAsyncOperation<bool> TrySetDefaultVoiceAsync(VoiceInformation voice);
  }
  public sealed class SpeechSynthesizerOptions {
    double AudioPitch { get; set; }
    double AudioVolume { get; set; }
    double SpeakingRate { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    HResult ExtendedError { get; }
  }
  public enum AdaptiveMediaSourceDiagnosticType {
    FatalMediaSourceError = 8,
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public struct BackgroundTransferFileRange
  public sealed class BackgroundTransferRangesDownloadedEventArgs
  public enum BackgroundTransferStatus {
    PausedRecoverableWebErrorStatus = 8,
  }
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    IReference<WebErrorStatus> CurrentWebErrorStatus { get; }
    bool IsRandomAccessRequired { get; set; }
    IVector<WebErrorStatus> RecoverableWebErrorStatuses { get; }
    Uri RequestedUri { get; set; }
    event TypedEventHandler<DownloadOperation, BackgroundTransferRangesDownloadedEventArgs> RangesDownloaded;
    IVector<BackgroundTransferFileRange> GetDownloadedRanges();
    IRandomAccessStreamReference GetResultRandomAccessStreamReference();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class ConnectionProfile {
    IAsyncOperation<IVectorView<ProviderNetworkUsage>> GetProviderNetworkUsageAsync(DateTime startTime, DateTime endTime, NetworkUsageStates states);
  }
  public sealed class ProviderNetworkUsage
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAntennaSar
  public sealed class MobileBroadbandCellCdma
  public sealed class MobileBroadbandCellGsm
  public sealed class MobileBroadbandCellLte
  public sealed class MobileBroadbandCellsInfo
  public sealed class MobileBroadbandCellTdscdma
  public sealed class MobileBroadbandCellUmts
  public sealed class MobileBroadbandModem {
    IAsyncOperation<bool> GetIsPassthroughEnabledAsync();
    IAsyncOperation<MobileBroadbandModemStatus> SetIsPassthroughEnabledAsync(bool value);
  }
  public sealed class MobileBroadbandModemConfiguration {
    MobileBroadbandSarManager SarManager { get; }
  }
  public enum MobileBroadbandModemStatus
  public sealed class MobileBroadbandNetwork {
    IAsyncOperation<MobileBroadbandCellsInfo> GetCellsInfoAsync();
  }
  public sealed class MobileBroadbandSarManager
  public sealed class MobileBroadbandTransmissionStateChangedEventArgs
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
    MessageWebSocketReceiveMode ReceiveMode { get; set; }
  }
  public sealed class MessageWebSocketMessageReceivedEventArgs {
    bool IsMessageComplete { get; }
  }
  public enum MessageWebSocketReceiveMode
  public enum SocketProtectionLevel {
    Unspecified = 9,
  }
  public sealed class StreamSocketControl {
    SocketProtectionLevel MinProtectionLevel { get; set; }
  }
  public sealed class StreamWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public static class WebAccountManager {
    public static IAsyncAction InvalidateAppCacheForAccountAsync(WebAccount webAccount);
    public static IAsyncAction InvalidateAppCacheForAllAccountsAsync();
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRoute {
    bool IsScenic { get; }
  }
  public enum MapRouteOptimization {
    Scenic = 3,
  }
  public sealed class PlaceInfo
  public sealed class PlaceInfoCreateOptions
}
namespace Windows.Storage {
  public sealed class StorageLibrary {
    IAsyncOperation<bool> AreFolderSuggestionsAvailableAsync();
  }
  public sealed class StorageProvider {
    IAsyncOperation<bool> IsPropertySupportedForPartialFileAsync(string propertyCanonicalName);
  }
}
namespace Windows.Storage.Search {
  public enum IndexerOption {
    OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
  }
}
namespace Windows.Storage.Streams {
  public enum FileOpenDisposition
  public sealed class FileRandomAccessStream : IClosable, IInputStream, IOutputStream, IRandomAccessStream {
    public static IAsyncOperation<IRandomAccessStream> OpenAsync(string filePath, FileAccessMode accessMode);
    public static IAsyncOperation<IRandomAccessStream> OpenAsync(string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation<IRandomAccessStream> OpenForUserAsync(User user, string filePath, FileAccessMode accessMode);
    public static IAsyncOperation<IRandomAccessStream> OpenForUserAsync(User user, string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(string filePath);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteForUserAsync(User user, string filePath);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteForUserAsync(User user, string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
  }
}
namespace Windows.System {
  public sealed class AppDiagnosticInfo {
    AppResourceGroupInfoWatcher CreateResourceGroupWatcher();
    public static AppDiagnosticInfoWatcher CreateWatcher();
    IVector<AppResourceGroupInfo> GetResourceGroups();
    public static IAsyncOperation<DiagnosticAccessStatus> RequestAccessAsync();
    public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForAppAsync();
    public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForAppAsync(string appUserModelId);
    public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForPackageAsync(string packageFamilyName);
  }
  public sealed class AppDiagnosticInfoWatcher
  public sealed class AppDiagnosticInfoWatcherEventArgs
  public enum AppDiagnosticInfoWatcherStatus
  public sealed class AppMemoryReport {
    ulong ExpectedTotalCommitLimit { get; }
  }
  public sealed class AppResourceGroupBackgroundTaskReport
  public enum AppResourceGroupEnergyQuotaState
  public enum AppResourceGroupExecutionState
  public sealed class AppResourceGroupInfo
  public sealed class AppResourceGroupInfoWatcher
  public sealed class AppResourceGroupInfoWatcherEventArgs
  public sealed class AppResourceGroupInfoWatcherExecutionStateChangedEventArgs
  public enum AppResourceGroupInfoWatcherStatus
  public sealed class AppResourceGroupMemoryReport
  public sealed class AppResourceGroupStateReport
  public enum DiagnosticAccessStatus
  public sealed class DispatcherQueue
  public sealed class DispatcherQueueController
  public delegate void DispatcherQueueHandler();
  public enum DispatcherQueuePriority
  public sealed class DispatcherQueueShutdownStartingEventArgs
  public sealed class DispatcherQueueTimer
  public static class MemoryManager {
    public static ulong ExpectedAppMemoryUsageLimit { get; }
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticActionResult
  public enum DiagnosticActionState
  public sealed class DiagnosticInvoker
  public sealed class ProcessDiagnosticInfo {
    bool IsPackaged { get; }
    IVector<AppDiagnosticInfo> GetAppDiagnosticInfos();
    public static ProcessDiagnosticInfo TryGetForProcessId(uint processId);
  }
}
namespace Windows.System.Profile {
  public enum SystemIdentificationSource {
    Registry = 3,
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    string ManufacturerDisplayName { get; }
    string ModelDisplayName { get; }
  }
  public static class RemoteSystemKinds {
    public static string Iot { get; }
    public static string Laptop { get; }
    public static string Tablet { get; }
  }
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static bool TrySetHomeGeographicRegion(string region);
    public static bool TrySetLanguages(IIterable<string> languageTags);
  }
}
namespace Windows.UI.Composition {
  public sealed class AmbientLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
    InitialValueExpressionCollection InitialValueExpressions { get; }
  }
  public sealed class CompositionColorGradientStop : CompositionObject
  public sealed class CompositionColorGradientStopCollection : IIterable<CompositionColorGradientStop>, IVector<CompositionColorGradientStop>
  public enum CompositionColorSpace {
    HslLinear = 3,
    RgbLinear = 4,
  }
  public enum CompositionDropShadowSourcePolicy
  public class CompositionGradientBrush : CompositionBrush
  public enum CompositionGradientExtendMode
  public class CompositionLight : CompositionObject {
    VisualUnorderedCollection ExclusionsFromTargets { get; }
  }
  public sealed class CompositionLinearGradientBrush : CompositionGradientBrush
  public class CompositionObject : IClosable {
    DispatcherQueue DispatcherQueue { get; }
  }
  public class CompositionTarget : CompositionObject {
  }
  public sealed class Compositor : IClosable {
    CompositionColorGradientStop CreateColorGradientStop();
    CompositionColorGradientStop CreateColorGradientStop(float offset, Color color);
    CompositionLinearGradientBrush CreateLinearGradientBrush();
    SpringScalarNaturalMotionAnimation CreateSpringScalarAnimation();
    SpringVector2NaturalMotionAnimation CreateSpringVector2Animation();
    SpringVector3NaturalMotionAnimation CreateSpringVector3Animation();
  }
  public sealed class DistantLight : CompositionLight {
    float Intensity { get; set; }
  }
  public sealed class DropShadow : CompositionShadow {
    CompositionDropShadowSourcePolicy SourcePolicy { get; set; }
  }
  public sealed class InitialValueExpressionCollection : CompositionObject, IIterable<IKeyValuePair<string, string>>, IMap<string, string>
  public sealed class LayerVisual : ContainerVisual {
    CompositionShadow Shadow { get; set; }
  }
  public class NaturalMotionAnimation : CompositionAnimation
  public sealed class PointLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class ScalarNaturalMotionAnimation : NaturalMotionAnimation
  public sealed class SpotLight : CompositionLight {
    float InnerConeIntensity { get; set; }
    float OuterConeIntensity { get; set; }
  }
  public sealed class SpringScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class SpringVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class SpringVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public class Vector2NaturalMotionAnimation : NaturalMotionAnimation
  public class Vector3NaturalMotionAnimation : NaturalMotionAnimation
}
namespace Windows.UI.Composition.Effects {
  public sealed class SceneLightingEffect : IGraphicsEffect, IGraphicsEffectSource {
    SceneLightingEffectReflectanceModel ReflectanceModel { get; set; }
  }
  public enum SceneLightingEffectReflectanceModel
}
namespace Windows.UI.Composition.Interactions {
  public sealed class InteractionTracker : CompositionObject {
    void ConfigureVector2PositionInertiaModifiers(IIterable<InteractionTrackerVector2InertiaModifier> modifiers);
  }
  public sealed class InteractionTrackerInertiaNaturalMotion : InteractionTrackerInertiaModifier
  public class InteractionTrackerVector2InertiaModifier : CompositionObject
  public sealed class InteractionTrackerVector2InertiaNaturalMotion : InteractionTrackerVector2InertiaModifier
}
namespace Windows.UI.Core {
  public enum CoreCursorType {
    Person = 15,
    Pin = 14,
  }
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    CoreWindowActivationMode ActivationMode { get; }
    DispatcherQueue DispatcherQueue { get; }
  }
  public enum CoreWindowActivationMode
}
namespace Windows.UI.Input {
  public sealed class RadialControllerConfiguration {
    public static RadialController AppController { get; set; }
    public static bool IsAppControllerEnabled { get; set; }
  }
}
namespace Windows.UI.Input.Inking.Core {
  public sealed class CoreIncrementalInkStroke
  public sealed class CoreInkPresenterHost
}
namespace Windows.UI.Input.Preview.Injection {
  public sealed class InjectedInputGamepadInfo
  public sealed class InputInjector {
    void InitializeGamepadInjection();
    void InjectGamepadInput(InjectedInputGamepadInfo input);
    public static InputInjector TryCreateForAppBroadcastOnly();
    void UninitializeGamepadInjection();
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    IAsyncOperation<IRandomAccessStreamWithContentType> TryGetRenderableModelAsync();
  }
  public sealed class SpatialInteractionSource {
    SpatialInteractionSourceHandedness Handedness { get; }
  }
  public enum SpatialInteractionSourceHandedness
  public sealed class SpatialInteractionSourceLocation {
    IReference<Vector3> AngularVelocity { get; }
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
    SpatialPointerInteractionSourcePose SourcePointerPose { get; }
  }
  public enum SpatialInteractionSourcePositionAccuracy
  public sealed class SpatialPointerInteractionSourcePose {
    Quaternion Orientation { get; }
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
  }
}
namespace Windows.UI.Shell {
  public static class AdaptiveCardBuilder
  public interface IAdaptiveCard
  public interface IAdaptiveCardBuilderStatics
  public sealed class TaskbarManager
}
namespace Windows.UI.StartScreen {
  public sealed class SecondaryTileVisualElements {
    TileMixedRealityModel MixedRealityModel { get; }
  }
  public sealed class TileMixedRealityModel
}
namespace Windows.UI.Text.Core {
  public enum CoreTextInputScope {
    Digits = 28,
    PinAlphanumeric = 65,
    PinNumeric = 64,
  }
}
namespace Windows.UI.ViewManagement {
  public enum UIElementType {
    AccentColor = 1000,
    NonTextHigh = 1005,
    NonTextLow = 1009,
    NonTextMedium = 1007,
    NonTextMediumHigh = 1006,
    NonTextMediumLow = 1008,
    OverlayOutsidePopup = 1012,
    PageBackground = 1010,
    PopupBackground = 1011,
    TextContrastWithHigh = 1004,
    TextHigh = 1001,
    TextLow = 1003,
    TextMedium = 1002,
  }
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView
  public sealed class CoreInputViewOcclusion
  public enum CoreInputViewOcclusionKind
  public sealed class CoreInputViewOcclusionsChangedEventArgs
}
namespace Windows.UI.WebUI {
  public static class WebUIApplication {
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync(string launchArguments);
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class WebUICommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class WebUIStartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.UI.Xaml {
  public class FrameworkElement : UIElement {
    ElementTheme ActualTheme { get; }
    public static DependencyProperty ActualThemeProperty { get; }
    event TypedEventHandler<FrameworkElement, object> ActualThemeChanged;
  }
  public enum TextAlignment {
    End = 2,
    Start = 1,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent CharacterReceivedEvent { get; }
    IVector<KeyboardAccelerator> KeyboardAccelerators { get; }
    public static RoutedEvent PreviewKeyDownEvent { get; }
    public static RoutedEvent PreviewKeyUpEvent { get; }
    event TypedEventHandler<UIElement, CharacterReceivedRoutedEventArgs> CharacterReceived;
    event KeyEventHandler PreviewKeyDown;
    event KeyEventHandler PreviewKeyUp;
    event TypedEventHandler<UIElement, ProcessKeyboardAcceleratorEventArgs> ProcessKeyboardAccelerators;
    virtual IIterable<DependencyObject> GetChildrenInTabFocusOrder();
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationNotificationKind
  public enum AutomationNotificationProcessing
  public class AutomationPeer : DependencyObject {
    void RaiseNotificationEvent(AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, string displayString, string activityId);
  }
  public class ColorPickerSliderAutomationPeer : SliderAutomationPeer
  public class ColorSpectrumAutomationPeer : FrameworkElementAutomationPeer
  public class NavigationViewItemAutomationPeer : ListViewItemAutomationPeer
  public class PersonPictureAutomationPeer : FrameworkElementAutomationPeer
  public class RatingControlAutomationPeer : FrameworkElementAutomationPeer
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class BitmapIconSource : IconSource
  public enum CharacterCasing
  public sealed class ColorChangedEventArgs
  public class ColorPicker : Control
  public enum ColorPickerHsvChannel
  public enum ColorSpectrumComponents
  public enum ColorSpectrumShape
  public class ComboBox : Selector {
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
  }
  public class ContentDialog : ContentControl {
    IAsyncOperation<ContentDialogResult> ShowAsync(ContentDialogPlacement placement);
  }
  public enum ContentDialogPlacement
  public class Control : FrameworkElement {
    virtual void OnCharacterReceived(CharacterReceivedRoutedEventArgs e);
    virtual void OnPreviewKeyDown(KeyRoutedEventArgs e);
    virtual void OnPreviewKeyUp(KeyRoutedEventArgs e);
  }
  public enum DisabledFormattingAccelerators : uint
  public class FontIconSource : IconSource
  public class Grid : Panel {
    double ColumnSpacing { get; set; }
    public static DependencyProperty ColumnSpacingProperty { get; }
    double RowSpacing { get; set; }
    public static DependencyProperty RowSpacingProperty { get; }
  }
  public class IconSource : DependencyObject
  public sealed class IsTextTrimmedChangedEventArgs
  public class MediaTransportControls : Control {
    bool IsRepeatButtonVisible { get; set; }
    public static DependencyProperty IsRepeatButtonVisibleProperty { get; }
    bool IsRepeatEnabled { get; set; }
    public static DependencyProperty IsRepeatEnabledProperty { get; }
    bool ShowAndHideAutomatically { get; set; }
    public static DependencyProperty ShowAndHideAutomaticallyProperty { get; }
    void Hide();
    void Show();
  }
  public class NavigationView : ContentControl
  public enum NavigationViewDisplayMode
  public sealed class NavigationViewDisplayModeChangedEventArgs
  public class NavigationViewItem : NavigationViewItemBase
  public class NavigationViewItemBase : ListViewItem
  public class NavigationViewItemHeader : NavigationViewItemBase
  public sealed class NavigationViewItemInvokedEventArgs
  public class NavigationViewItemSeparator : NavigationViewItemBase
  public class NavigationViewList : ListView
  public sealed class NavigationViewSelectionChangedEventArgs
  public enum ParallaxSourceOffsetKind
  public class ParallaxView : FrameworkElement
  public sealed class PasswordBox : Control {
    event TypedEventHandler<PasswordBox, PasswordBoxPasswordChangingEventArgs> PasswordChanging;
  }
  public sealed class PasswordBoxPasswordChangingEventArgs
  public class PathIconSource : IconSource
  public class PersonPicture : Control
  public class RatingControl : Control
  public class RatingItemFontInfo : RatingItemInfo
  public class RatingItemImageInfo : RatingItemInfo
  public class RatingItemInfo : DependencyObject
  public class RichEditBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    DisabledFormattingAccelerators DisabledFormattingAccelerators { get; set; }
    public static DependencyProperty DisabledFormattingAcceleratorsProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    event TypedEventHandler<RichEditBox, TextControlCopyingToClipboardEventArgs> CopyingToClipboard;
    event TypedEventHandler<RichEditBox, TextControlCuttingToClipboardEventArgs> CuttingToClipboard;
  }
  public sealed class RichTextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector<TextHighlighter> TextHighlighters { get; }
    event TypedEventHandler<RichTextBlock, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
  }
  public sealed class RichTextBlockOverflow : FrameworkElement {
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    event TypedEventHandler<RichTextBlockOverflow, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
  }
  public class SplitView : Control {
    event TypedEventHandler<SplitView, object> PaneOpened;
    event TypedEventHandler<SplitView, object> PaneOpening;
  }
  public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
    double Spacing { get; set; }
    public static DependencyProperty SpacingProperty { get; }
  }
  public enum SwipeBehaviorOnInvoked
  public class SwipeControl : ContentControl
  public class SwipeItem : DependencyObject
  public sealed class SwipeItemInvokedEventArgs
  public class SwipeItems : DependencyObject, IIterable<SwipeItem>, IVector<SwipeItem>
  public enum SwipeMode
  public enum Symbol {
    GlobalNavigationButton = 59136,
    Print = 59209,
    Share = 59181,
    XboxOneConsole = 59792,
  }
  public class SymbolIconSource : IconSource
  public sealed class TextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector<TextHighlighter> TextHighlighters { get; }
    event TypedEventHandler<TextBlock, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
  }
  public class TextBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
    event TypedEventHandler<TextBox, TextBoxBeforeTextChangingEventArgs> BeforeTextChanging;
    event TypedEventHandler<TextBox, TextControlCopyingToClipboardEventArgs> CopyingToClipboard;
    event TypedEventHandler<TextBox, TextControlCuttingToClipboardEventArgs> CuttingToClipboard;
  }
  public sealed class TextBoxBeforeTextChangingEventArgs
  public sealed class TextControlCopyingToClipboardEventArgs
  public sealed class TextControlCuttingToClipboardEventArgs
  public class TreeView : Control
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemClickEventArgs
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject, IBindableIterable, IBindableObservableVector, IBindableVector
  public enum TreeViewSelectionMode
  public sealed class XamlBooleanToVisibilityConverter : IValueConverter
  public sealed class XamlIntegerToIndentationConverter : IValueConverter
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    IVector<MapLayer> Layers { get; set; }
    public static DependencyProperty LayersProperty { get; }
    bool TryGetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
    bool TryGetLocationFromOffset(Point offset, out Geopoint location);
  }
  public class MapElement : DependencyObject {
    string MapStyleSheetEntry { get; set; }
    public static DependencyProperty MapStyleSheetEntryProperty { get; }
    string MapStyleSheetEntryState { get; set; }
    public static DependencyProperty MapStyleSheetEntryStateProperty { get; }
    object Tag { get; set; }
    public static DependencyProperty TagProperty { get; }
  }
  public sealed class MapElement3D : MapElement
  public sealed class MapElementsLayer : MapLayer
  public sealed class MapElementsLayerClickEventArgs
  public sealed class MapElementsLayerContextRequestedEventArgs
  public sealed class MapElementsLayerPointerEnteredEventArgs
  public sealed class MapElementsLayerPointerExitedEventArgs
  public class MapLayer : DependencyObject
  public class MapModel3D : DependencyObject
  public enum MapModel3DShadingOption
  public static class MapStyleSheetEntries
  public static class MapStyleSheetEntryStates
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class ColorPickerSlider : Slider
  public class ColorSpectrum : Control
  public class FlyoutBase : DependencyObject {
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
  public sealed class LayoutInformation {
    public static Size GetAvailableSize(UIElement element);
  }
  public class ListViewItemPresenter : ContentPresenter {
    Brush RevealBackground { get; set; }
    public static DependencyProperty RevealBackgroundProperty { get; }
    bool RevealBackgroundShowsAboveContent { get; set; }
    public static DependencyProperty RevealBackgroundShowsAboveContentProperty { get; }
    Brush RevealBorderBrush { get; set; }
    public static DependencyProperty RevealBorderBrushProperty { get; }
    Thickness RevealBorderThickness { get; set; }
    public static DependencyProperty RevealBorderThicknessProperty { get; }
  }
}
namespace Windows.UI.Xaml.Data {
  public enum UpdateSourceTrigger {
    LostFocus = 3,
  }
}
namespace Windows.UI.Xaml.Documents {
  public class Block : TextElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
  }
  public sealed class Hyperlink : Span {
    bool IsTabStop { get; set; }
    public static DependencyProperty IsTabStopProperty { get; }
    int TabIndex { get; set; }
    public static DependencyProperty TabIndexProperty { get; }
  }
  public class TextHighlighter
  public class TextHighlighterBase : DependencyObject
  public struct TextRange
}
namespace Windows.UI.Xaml.Input {
  public sealed class CharacterReceivedRoutedEventArgs : RoutedEventArgs
  public class KeyboardAccelerator : DependencyObject
  public sealed class KeyboardAcceleratorInvokedEventArgs
  public sealed class PointerRoutedEventArgs : RoutedEventArgs {
    bool IsGenerated { get; }
  }
  public sealed class ProcessKeyboardAcceleratorEventArgs
}
namespace Windows.UI.Xaml.Markup {
  public class MarkupExtension
  public sealed class MarkupExtensionReturnTypeAttribute : Attribute
}
namespace Windows.UI.Xaml.Media {
  public enum AcrylicBackgroundSource
  public class AcrylicBrush : XamlCompositionBrushBase
  public class RevealBackgroundBrush : RevealBrush
  public class RevealBorderBrush : RevealBrush
  public class RevealBrush : XamlCompositionBrushBase
  public enum RevealBrushState
}
namespace Windows.Web {
  public enum WebErrorStatus {
    InsufficientRangeSupport = 22,
    MissingContentLengthSupport = 23,
  }
}
 
namespace Windows.Gaming.Preview.GamesEnumeration {
  public static class GameList {
    public static IAsyncOperation<GameListEntry> MergeEntriesAsync(GameListEntry left, GameListEntry right);
    public static IAsyncOperation<IVectorView<GameListEntry>> UnmergeEntryAsync(GameListEntry mergedEntry);
  }
  public sealed class GameListEntry : IGameListEntry {
    GameModeConfiguration GameModeConfiguration { get; }
    GameListEntryLaunchableState LaunchableState { get; }
    IStorageFile LauncherExecutable { get; }
    string LaunchParameters { get; }
    string TitleId { get; }
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile);
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile, string launchParams);
    IAsyncAction SetTitleIdAsync(string id);
  }
  public enum GameListEntryLaunchableState
  public sealed class GameModeConfiguration
  public sealed class GameModeUserConfiguration
}
namespace Windows.Graphics.Printing3D {
  public sealed class Printing3D3MFPackage {
    Printing3DPackageCompression Compression { get; set; }
  }
  public enum Printing3DPackageCompression
}
namespace Windows.Media.Capture {
  public sealed class AppBroadcastBackgroundService {
    string BroadcastChannel { get; set; }
    string BroadcastLanguage { get; set; }
    string BroadcastTitle { get; set; }
    event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastChannelChanged;
    event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastLanguageChanged;
    event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastTitleChanged;
  }
  public sealed class AppBroadcastBackgroundServiceSignInInfo {
    event TypedEventHandler<AppBroadcastBackgroundServiceSignInInfo, object> UserNameChanged;
  }
  public sealed class AppBroadcastBackgroundServiceStreamInfo {
    void ReportProblemWithStream();
  }
}
namespace Windows.Security.EnterpriseData {
  public sealed class FileProtectionInfo {
    bool IsProtectWhileOpenSupported { get; }
  }
}
namespace Windows.Services.Maps.Guidance {
  public sealed class GuidanceRoadSegment {
    bool IsScenic { get; }
  }
}
namespace Windows.Services.Maps.LocalSearch {
  public static class PlaceInfoHelper
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControlDataHelper : DependencyObject {
    public static MapControl CreateMapControl(bool rasterRenderMode);
  }
}
namespace Windows.System.Profile.SystemManufacturers {
  public sealed class OemSupportInfo
  public static class SystemSupportInfo
}
namespace Windows.System {
  public static class DateTimeSettings
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class DesignerAppExitedEventArgs
  public sealed class DesignerAppManager : IClosable
  public sealed class DesignerAppView : IClosable
  public enum DesignerAppViewState
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool IsPrimaryLayerEnabled { get; set; }
    uint MaxQuadLayerCount { get; }
    IVector<HolographicQuadLayer> QuadLayers { get; }
  }
  public sealed class HolographicCameraRenderingParameters {
    bool IsContentProtectionEnabled { get; set; }
  }
  public sealed class HolographicFrame {
    HolographicQuadLayerUpdateParameters GetQuadLayerUpdateParameters(HolographicQuadLayer layer);
  }
  public sealed class HolographicQuadLayer : IClosable
  public sealed class HolographicQuadLayerUpdateParameters
}
namespace Windows.UI.Input.Spatial {
  public enum SpatialInteractionSourceHandedness {
    Unspecified = 0,
  }
  public sealed class SpatialInteractionSourceLocation {
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
  }
  public enum SpatialInteractionSourcePositionAccuracy
  public sealed class SpatialPointerInteractionSourcePose {
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
  }
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class DesignerAppExitedEventArgs
  public sealed class DesignerAppManager : IClosable
  public sealed class DesignerAppView : IClosable
  public enum DesignerAppViewState
  public struct HostingContract
  public interface IXamlUIPresenterHost
  public interface IXamlUIPresenterHost2
  public interface IXamlUIPresenterHost3
  public sealed class XamlUIPresenter
}
 

API Removals


namespace Windows.UI.Composition {
  public sealed class CompositionTarget : CompositionObject {
  }
}

namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    PresentationLayerDrmMode DrmMode { get; set; }
    PresentationLayerConfig CreateLayerConfig();
    PresentationLayers GetPresentationLayers();
    void SetLayerConfig(PresentationLayerConfig layerConfig);
  }
  public sealed class HolographicCameraRenderingParameters {
    PresentationLayerRenderingParametersQuad GetPresentationLayerRenderingParameters(PresentationLayerQuad layer);
  }
  public sealed class PresentationLayerConfig
  public enum PresentationLayerDrmMode
  public sealed class PresentationLayerQuad
  public sealed class PresentationLayerReference
  public sealed class PresentationLayerRenderingParametersQuad
  public sealed class PresentationLayers
  public sealed class PresentationLayerSettings
  public enum PresentationLayerType
}
 
namespace Windows.UI.Input.Spatial {
  public enum SpatialInteractionSourceHandedness {
    Both = 3,
    Unknown = 0,
  }
 
  public sealed class SpatialInteractionSourceLocation {
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
  }
 
  public enum SpatialInteractionSourcePositionQuality
  public sealed class SpatialPointerInteractionSourcePose {
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
  }
}

Windows 10 SDK Preview Build 16225 Released

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 16225 or greater). The Preview SDK Build 16225 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 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

  • Designer fails to render: When viewing the XAML in the Designer Window in Visual Studio, the controls fail to render. This can be resolved by using Visual Studio 2017.3 Preview.
  • Compilation fails on non-Windows 10 platforms: When building apps on previous platforms, you may get a build error:

C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll:C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll(0,0): Error WMC0621: Cannot resolve ‘GenXbf.dll’ under path ‘C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll’. Please install the latest version of the Windows 10 Software Development Kit.
Process ‘msbuild.exe’ exited with code ‘1’.

This will occur if the minimum target platform version is set to 10.0.16225.0. To work around this, right click on your project file and choose properties or open your project file in your favorite editor, and change the version to a previous released SDK. For example:


<WindowsTargetPlatformMinVersion>10.0.10586.0</WindowsTargetPlatformMinVersion>

Breaking Changes

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.

 
namespace Windows.ApplicationModel.Calls {
  public sealed class VoipCallCoordinator {
    VoipPhoneCall SetupNewAcceptedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
  }
  public sealed class VoipPhoneCall {
    void TryShowAppUI();
  }
}
namespace Windows.ApplicationModel {
  public enum StartupTaskState {
    DisabledByPolicy = 3,
  }
}
namespace Windows.Devices.SmartCards {
  public sealed class SmartCardCryptogramGenerator {
    public static bool IsSupported();
  }
  public enum SmartCardCryptogramGeneratorOperationStatus {
    NotSupported = 13,
  }
  public sealed class SmartCardEmulator {
    public static bool IsSupported();
  }
}
namespace Windows.ApplicationModel {
  public static class DesignMode {
    public static bool DesignMode2Enabled { get; }
  }
  public sealed class PackageCatalog {
    IAsyncOperation<PackageCatalogRemoveOptionalPackagesResult> RemoveOptionalPackagesAsync(IIterable<string> optionalPackageFamilyNames);
  }
  public sealed class PackageCatalogRemoveOptionalPackagesResult
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    CommandLineLaunch = 1021,
    GameUIProvider = 1019,
    PrintWorkflowForegroundTask = 1018,
    StartupTask = 1020,
  }
  public sealed class CommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class CommandLineActivationOperation
  public interface ICommandLineActivatedEventArgs : IActivatedEventArgs
  public interface IStartupTaskActivatedEventArgs : IActivatedEventArgs
  public sealed class StartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.ApplicationModel.Appointments {
  public sealed class AppointmentStore {
    AppointmentStoreChangeTracker GetChangeTracker(string identity);
  }
  public sealed class AppointmentStoreChangeTracker {
    bool IsTracking { get; }
  }
}
namespace Windows.ApplicationModel.AppService {
  public sealed class AppServiceTriggerDetails {
    IAsyncOperation<bool> CheckCallerForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class GeovisitTrigger : IBackgroundTrigger
  public sealed class PaymentAppCanMakePaymentTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactChangeTracker {
    bool IsTracking { get; }
  }
  public sealed class ContactList {
    ContactListLimitedWriteOperations LimitedWriteOperations { get; }
    ContactChangeTracker GetChangeTracker(string identity);
  }
  public sealed class ContactListLimitedWriteOperations
  public enum ContactListOtherAppWriteAccess {
    Limited = 2,
  }
  public sealed class ContactStore {
    ContactChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Contacts.DataProvider {
  public sealed class ContactDataProviderConnection {
    event TypedEventHandler<ContactDataProviderConnection, ContactListCreateOrUpdateContactRequestEventArgs> CreateOrUpdateContactRequested;
    event TypedEventHandler<ContactDataProviderConnection, ContactListDeleteContactRequestEventArgs> DeleteContactRequested;
  }
  public sealed class ContactListCreateOrUpdateContactRequest
  public sealed class ContactListCreateOrUpdateContactRequestEventArgs
  public sealed class ContactListDeleteContactRequest
  public sealed class ContactListDeleteContactRequestEventArgs
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    string AppUserModelId { get; }
  }
  public enum AppRestartFailureReason
  public static class CoreApplication {
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync(string launchArguments);
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class CoreApplicationView {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataTransferManager {
    public static void ShowShareUI(ShareUIOptions options);
  }
  public sealed class ShareUIOptions
  public enum ShareUITheme
}
namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
  public sealed class ShareOperation {
    IVectorView<Contact> Contacts { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMailbox {
    EmailMailboxChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Payments {
  public sealed class PaymentCanMakePaymentResult
  public enum PaymentCanMakePaymentResultStatus
  public sealed class PaymentMediator {
    IAsyncOperation<PaymentCanMakePaymentResult> CanMakePaymentAsync(PaymentRequest paymentRequest);
  }
  public sealed class PaymentRequest {
    public PaymentRequest(PaymentDetails details, IIterable<PaymentMethodData> methodData, PaymentMerchantInfo merchantInfo, PaymentOptions options, string id);
    string Id { get; }
  }
}
namespace Windows.ApplicationModel.Payments.Provider {
  public sealed class PaymentAppCanMakePaymentTriggerDetails
}
namespace Windows.ApplicationModel.UserActivities {
  public interface IUserActivityContentInfo
  public sealed class UserActivity
  public sealed class UserActivityAttribution
  public sealed class UserActivityChannel
  public sealed class UserActivityContentInfo : IUserActivityContentInfo
  public sealed class UserActivitySession : IClosable
  public enum UserActivityState
  public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
  public static class CoreUserActivityManager
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
  public sealed class BluetoothDeviceId {
    public static BluetoothDeviceId FromId(string deviceId);
  }
  public sealed class BluetoothLEDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattClientNotificationResult {
    ushort BytesSent { get; }
  }
}
namespace Windows.Devices.Geolocation {
  public sealed class Geovisit
  public sealed class GeovisitMonitor
  public sealed class GeovisitStateChangedEventArgs
  public sealed class GeovisitTriggerDetails
  public enum VisitMonitoringScope
  public enum VisitStateChange
}
namespace Windows.Devices.PointOfService {
  public sealed class ClaimedLineDisplay : IClosable {
    LineDisplayCustomGlyphs CustomGlyphs { get; }
    Size MaxBitmapSizeInPixels { get; }
    IVectorView<int> SupportedCharacterSets { get; }
    IVectorView<Size> SupportedScreenSizesInCharacters { get; }
    event TypedEventHandler<ClaimedLineDisplay, LineDisplayStatusUpdatedEventArgs> StatusUpdated;
    IAsyncOperation<string> CheckHealthAsync(UnifiedPosHealthCheckLevel level);
    IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
    LineDisplayAttributes GetAttributes();
    IAsyncOperation<string> GetStatisticsAsync(IIterable<string> statisticsCategories);
    IAsyncOperation<bool> TryClearDescriptorsAsync();
    IAsyncOperation<LineDisplayWindow> TryCreateWindowAsync(Rect viewport, Size windowSize);
    IAsyncOperation<bool> TrySetDescriptorAsync(uint descriptor, LineDisplayDescriptorState descriptorState);
    IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap);
    IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation<bool> TryUpdateAttributesAsync(LineDisplayAttributes attributes);
  }
  public sealed class LineDisplay : IClosable {
    public static LineDisplayStatisticsCategorySelector StatisticsCategorySelector { get; }
    IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
  }
  public sealed class LineDisplayAttributes
  public sealed class LineDisplayCursor
  public sealed class LineDisplayCursorAttributes
  public enum LineDisplayCursorType
  public sealed class LineDisplayCustomGlyphs
  public enum LineDisplayDescriptorState
  public enum LineDisplayHorizontalAlignment
  public sealed class LineDisplayMarquee
  public enum LineDisplayMarqueeFormat
  public enum LineDisplayPowerStatus
  public sealed class LineDisplayStatisticsCategorySelector
  public sealed class LineDisplayStatusUpdatedEventArgs
  public sealed class LineDisplayStoredBitmap
  public enum LineDisplayVerticalAlignment
  public sealed class LineDisplayWindow : IClosable {
    LineDisplayCursor Cursor { get; }
    LineDisplayMarquee Marquee { get; }
    IAsyncOperation<uint> ReadCharacterAtCursorAsync();
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels);
    IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels, int widthInPixels);
    IAsyncOperation<bool> TryDisplayStoredBitmapAtCursorAsync(LineDisplayStoredBitmap bitmap);
  }
}
namespace Windows.Devices.Sensors {
  public sealed class Accelerometer {
    public static IAsyncOperation<Accelerometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector(AccelerometerReadingType readingType);
  }
  public sealed class AccelerometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Altimeter {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class AltimeterReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Barometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Barometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class BarometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Compass {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Compass> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class CompassReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Gyrometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Gyrometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class GyrometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Inclinometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Inclinometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
  }
  public sealed class InclinometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class LightSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<LightSensor> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class LightSensorReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class Magnetometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<Magnetometer> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class MagnetometerReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
  public sealed class OrientationSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation<OrientationSensor> FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
    public static string GetDeviceSelector(SensorReadingType readingType, SensorOptimizationGoal optimizationGoal);
  }
  public sealed class OrientationSensorReading {
    IReference<TimeSpan> PerformanceCount { get; }
    IMapView<string, object> Properties { get; }
  }
}
namespace Windows.Devices.Sensors.Custom {
  public sealed class CustomSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class CustomSensorReading {
    IReference<TimeSpan> PerformanceCount { get; }
  }
}
namespace Windows.Devices.WiFi {
  public sealed class WiFiAdapter {
    IAsyncOperation<WiFiConnectionResult> ConnectAsync(WiFiAvailableNetwork availableNetwork, WiFiReconnectionKind reconnectionKind, PasswordCredential passwordCredential, string ssid, WiFiConnectionMethod connectionMethod);
    IAsyncOperation<WiFiWpsConfigurationResult> GetWpsConfigurationAsync(WiFiAvailableNetwork availableNetwork);
  }
  public enum WiFiConnectionMethod
  public sealed class WiFiWpsConfigurationResult
  public enum WiFiWpsConfigurationStatus
  public enum WiFiWpsKind
}
namespace Windows.Gaming.Input {
  public sealed class RawGameController : IGameController, IGameControllerBatteryInfo {
    string DisplayName { get; }
    string NonRoamableId { get; }
    IVectorView<SimpleHapticsController> SimpleHapticsControllers { get; }
  }
}
namespace Windows.Gaming.UI {
  public sealed class GameMonitor
  public enum GameMonitoringPermission
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    PresentationLayerDrmMode DrmMode { get; set; }
    PresentationLayerConfig CreateLayerConfig();
    PresentationLayers GetPresentationLayers();
    void SetLayerConfig(PresentationLayerConfig layerConfig);
  }
  public sealed class HolographicCameraRenderingParameters {
    PresentationLayerRenderingParametersQuad GetPresentationLayerRenderingParameters(PresentationLayerQuad layer);
  }
  public sealed class HolographicDisplay {
    double RefreshRate { get; }
  }
  public sealed class HolographicSpace {
    public static bool IsConfigured { get; }
  }
  public sealed class PresentationLayerConfig
  public enum PresentationLayerDrmMode
  public sealed class PresentationLayerQuad
  public sealed class PresentationLayerReference
  public sealed class PresentationLayerRenderingParametersQuad
  public sealed class PresentationLayers
  public sealed class PresentationLayerSettings
  public enum PresentationLayerType
}
namespace Windows.Graphics.Printing.PrintTicket {
  public sealed class PrintTicketCapabilities
  public sealed class PrintTicketFeature
  public enum PrintTicketFeatureSelectionType
  public sealed class PrintTicketOption
  public enum PrintTicketParameterDataType
  public sealed class PrintTicketParameterDefinition
  public sealed class PrintTicketParameterInitializer
  public sealed class PrintTicketValue
  public enum PrintTicketValueType
  public sealed class WorkflowPrintTicket
  public sealed class WorkflowPrintTicketValidationResult
}
namespace Windows.Graphics.Printing.Workflow {
  public sealed class PrintWorkflowBackgroundSession
  public sealed class PrintWorkflowBackgroundSetupRequestedEventArgs
  public sealed class PrintWorkflowConfiguration
  public sealed class PrintWorkflowForegroundSession
  public sealed class PrintWorkflowForegroundSetupRequestedEventArgs
  public sealed class PrintWorkflowObjectModelSourceFileContent
  public sealed class PrintWorkflowObjectModelTargetPackage
  public enum PrintWorkflowSessionStatus
  public sealed class PrintWorkflowSourceContent
  public sealed class PrintWorkflowSpoolStreamContent
  public sealed class PrintWorkflowStreamTarget
  public sealed class PrintWorkflowSubmittedEventArgs
  public sealed class PrintWorkflowSubmittedOperation
  public enum PrintWorkflowSubmittedStatus
  public sealed class PrintWorkflowTarget
  public sealed class PrintWorkflowTriggerDetails
  public sealed class PrintWorkflowUIActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser
  public sealed class PrintWorkflowXpsDataAvailableEventArgs
}
namespace Windows.Management.Deployment {
  public enum AddPackageByAppInstallerOptions : uint
  public sealed class PackageManager {
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall, IIterable<Uri> relatedPackageUris);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> ProvisionPackageForAllUsersAsync(string packageFamilyName);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall, IIterable<Uri> relatedPackageUris);
  }
}
namespace Windows.Media.Capture {
  public sealed class AppCapture {
    public static IAsyncAction SetAllowedAsync(bool allowed);
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class MediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
  public enum MediaFrameReaderAcquisitionMode
  public sealed class MultiSourceMediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
  public interface IMediaStreamDescriptor2 : IMediaStreamDescriptor
  public sealed class InitializeMediaStreamSourceRequestedEventArgs
  public static class LowLightFusion
  public sealed class LowLightFusionResult : IClosable
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    public static MediaSource CreateFromMediaFrameSource(MediaFrameSource frameSource);
  }
  public sealed class MediaSourceAppServiceConnection
  public sealed class MediaStreamSource : IMediaSource {
    bool IsLive { get; set; }
  }
  public sealed class MseStreamSource : IMediaSource {
    IReference<MseTimeRange> LiveSeekableRange { get; set; }
  }
  public sealed class SceneAnalysisEffectFrame : IClosable, IMediaFrame {
    SceneAnalysisRecommendation AnalysisRecommendation { get; }
  }
  public enum SceneAnalysisRecommendation
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp
}
namespace Windows.Media.MediaProperties {
  public sealed class MediaEncodingProfile {
    IVector<AudioStreamDescriptor> GetAudioTracks();
    IVector<VideoStreamDescriptor> GetVideoTracks();
    void SetAudioTracks(IIterable<AudioStreamDescriptor> value);
    void SetVideoTracks(IIterable<VideoStreamDescriptor> value);
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSessionBufferingStartedEventArgs
  public sealed class MediaPlayer : IClosable {
    event TypedEventHandler<MediaPlayer, object> SubtitleFrameChanged;
    bool RenderSubtitlesToSurface(IDirect3DSurface destination);
    bool RenderSubtitlesToSurface(IDirect3DSurface destination, Rect targetRectangle);
  }
}
namespace Windows.Media.Protection.PlayReady {
  public enum PlayReadyEncryptionAlgorithm {
    Aes128Cbc = 5,
    Unspecified = 65535,
  }
  public enum PlayReadyHardwareDRMFeatures {
    Aes128Cbc = 3,
  }
}
namespace Windows.Media.SpeechRecognition {
  public sealed class SpeechRecognizer : IClosable {
    public static IAsyncOperation<bool> TrySetSystemSpeechLanguageAsync(Language speechLanguage);
  }
}
namespace Windows.Media.SpeechSynthesis {
  public sealed class SpeechSynthesizer : IClosable {
    public static IAsyncOperation<bool> TrySetDefaultVoiceAsync(VoiceInformation voice);
  }
  public sealed class SpeechSynthesizerOptions {
    double AudioPitch { get; set; }
    double AudioVolume { get; set; }
    double SpeakingRate { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    HResult ExtendedError { get; }
  }
  public enum AdaptiveMediaSourceDiagnosticType {
    FatalMediaSourceError = 8,
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public struct BackgroundTransferFileRange
  public sealed class BackgroundTransferRangesDownloadedEventArgs
  public enum BackgroundTransferStatus {
    PausedRecoverableWebErrorStatus = 8,
  }
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    IReference<WebErrorStatus> CurrentWebErrorStatus { get; }
    bool IsRandomAccessRequired { get; set; }
    IVector<WebErrorStatus> RecoverableWebErrorStatuses { get; }
    Uri RequestedUri { get; set; }
    event TypedEventHandler<DownloadOperation, BackgroundTransferRangesDownloadedEventArgs> RangesDownloaded;
    IVector<BackgroundTransferFileRange> GetDownloadedRanges();
    IRandomAccessStreamReference GetResultRandomAccessStreamReference();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class ConnectionProfile {
    IAsyncOperation<IVectorView<ProviderNetworkUsage>> GetProviderNetworkUsageAsync(DateTime startTime, DateTime endTime, NetworkUsageStates states);
  }
  public sealed class ProviderNetworkUsage
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAntennaSar
  public sealed class MobileBroadbandCellCdma
  public sealed class MobileBroadbandCellGsm
  public sealed class MobileBroadbandCellLte
  public sealed class MobileBroadbandCellsInfo
  public sealed class MobileBroadbandCellTdscdma
  public sealed class MobileBroadbandCellUmts
  public sealed class MobileBroadbandModem {
    IAsyncOperation<bool> GetIsPassthroughEnabledAsync();
    IAsyncOperation<MobileBroadbandModemStatus> SetIsPassthroughEnabledAsync(bool value);
  }
  public sealed class MobileBroadbandModemConfiguration {
    MobileBroadbandSarManager SarManager { get; }
  }
  public enum MobileBroadbandModemStatus
  public sealed class MobileBroadbandNetwork {
    IAsyncOperation<MobileBroadbandCellsInfo> GetCellsInfoAsync();
  }
  public sealed class MobileBroadbandSarManager
  public sealed class MobileBroadbandTransmissionStateChangedEventArgs
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
    MessageWebSocketReceiveMode ReceiveMode { get; set; }
  }
  public sealed class MessageWebSocketMessageReceivedEventArgs {
    bool IsMessageComplete { get; }
  }
  public enum MessageWebSocketReceiveMode
  public enum SocketProtectionLevel {
    Unspecified = 9,
  }
  public sealed class StreamSocketControl {
    SocketProtectionLevel MinProtectionLevel { get; set; }
  }
  public sealed class StreamWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public static class WebAccountManager {
    public static IAsyncAction InvalidateAppCacheForAccountAsync(WebAccount webAccount);
    public static IAsyncAction InvalidateAppCacheForAllAccountsAsync();
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRoute {
    bool IsScenic { get; }
  }
  public enum MapRouteOptimization {
    Scenic = 3,
  }
  public sealed class PlaceInfo
  public sealed class PlaceInfoCreateOptions
}
namespace Windows.Storage {
  public sealed class StorageLibrary {
    IAsyncOperation<bool> AreFolderSuggestionsAvailableAsync();
  }
  public sealed class StorageProvider {
    IAsyncOperation<bool> IsPropertySupportedForPartialFileAsync(string propertyCanonicalName);
  }
}
namespace Windows.Storage.Search {
  public enum IndexerOption {
    OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
  }
}
namespace Windows.Storage.Streams {
  public enum FileOpenDisposition
  public sealed class FileRandomAccessStream : IClosable, IInputStream, IOutputStream, IRandomAccessStream {
    public static IAsyncOperation<IRandomAccessStream> OpenAsync(string filePath, FileAccessMode accessMode);
    public static IAsyncOperation<IRandomAccessStream> OpenAsync(string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation<IRandomAccessStream> OpenForUserAsync(User user, string filePath, FileAccessMode accessMode);
    public static IAsyncOperation<IRandomAccessStream> OpenForUserAsync(User user, string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(string filePath);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteForUserAsync(User user, string filePath);
    public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteForUserAsync(User user, string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
  }
}
namespace Windows.System {
  public sealed class AppDiagnosticInfo {
    AppResourceGroupInfoWatcher CreateResourceGroupWatcher();
    public static AppDiagnosticInfoWatcher CreateWatcher();
    IVector<AppResourceGroupInfo> GetResourceGroups();
    public static IAsyncOperation<DiagnosticAccessStatus> RequestAccessAsync();
    public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForAppAsync();
    public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForAppAsync(string appUserModelId);
    public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForPackageAsync(string packageFamilyName);
  }
  public sealed class AppDiagnosticInfoWatcher
  public sealed class AppDiagnosticInfoWatcherEventArgs
  public enum AppDiagnosticInfoWatcherStatus
  public sealed class AppMemoryReport {
    ulong ExpectedTotalCommitLimit { get; }
  }
  public sealed class AppResourceGroupBackgroundTaskReport
  public enum AppResourceGroupEnergyQuotaState
  public enum AppResourceGroupExecutionState
  public sealed class AppResourceGroupInfo
  public sealed class AppResourceGroupInfoWatcher
  public sealed class AppResourceGroupInfoWatcherEventArgs
  public sealed class AppResourceGroupInfoWatcherExecutionStateChangedEventArgs
  public enum AppResourceGroupInfoWatcherStatus
  public sealed class AppResourceGroupMemoryReport
  public sealed class AppResourceGroupStateReport
  public enum DiagnosticAccessStatus
  public sealed class DispatcherQueue
  public sealed class DispatcherQueueController
  public delegate void DispatcherQueueHandler();
  public enum DispatcherQueuePriority
  public sealed class DispatcherQueueShutdownStartingEventArgs
  public sealed class DispatcherQueueTimer
  public static class MemoryManager {
    public static ulong ExpectedAppMemoryUsageLimit { get; }
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticActionResult
  public enum DiagnosticActionState
  public sealed class DiagnosticInvoker
  public sealed class ProcessDiagnosticInfo {
    bool IsPackaged { get; }
    IVector<AppDiagnosticInfo> GetAppDiagnosticInfos();
    public static ProcessDiagnosticInfo TryGetForProcessId(uint processId);
  }
}
namespace Windows.System.Profile {
  public enum SystemIdentificationSource {
    Registry = 3,
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    string ManufacturerDisplayName { get; }
    string ModelDisplayName { get; }
  }
  public static class RemoteSystemKinds {
    public static string Iot { get; }
    public static string Laptop { get; }
    public static string Tablet { get; }
  }
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static bool TrySetHomeGeographicRegion(string region);
    public static bool TrySetLanguages(IIterable<string> languageTags);
  }
}
namespace Windows.UI.Composition {
  public sealed class AmbientLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
    InitialValueExpressionCollection InitialValueExpressions { get; }
  }
  public sealed class CompositionColorGradientStop : CompositionObject
  public sealed class CompositionColorGradientStopCollection : IIterable<CompositionColorGradientStop>, IVector<CompositionColorGradientStop>
  public enum CompositionColorSpace {
    HslLinear = 3,
    RgbLinear = 4,
  }
  public enum CompositionDropShadowSourcePolicy
  public class CompositionGradientBrush : CompositionBrush
  public enum CompositionGradientExtendMode
  public class CompositionLight : CompositionObject {
    VisualUnorderedCollection ExclusionsFromTargets { get; }
  }
  public sealed class CompositionLinearGradientBrush : CompositionGradientBrush
  public class CompositionObject : IClosable {
    DispatcherQueue DispatcherQueue { get; }
  }
  public sealed class CompositionTarget : CompositionObject {
  }
  public sealed class Compositor : IClosable {
    CompositionColorGradientStop CreateColorGradientStop();
    CompositionColorGradientStop CreateColorGradientStop(float offset, Color color);
    CompositionLinearGradientBrush CreateLinearGradientBrush();
    SpringScalarNaturalMotionAnimation CreateSpringScalarAnimation();
    SpringVector2NaturalMotionAnimation CreateSpringVector2Animation();
    SpringVector3NaturalMotionAnimation CreateSpringVector3Animation();
  }
  public sealed class DistantLight : CompositionLight {
    float Intensity { get; set; }
  }
  public sealed class DropShadow : CompositionShadow {
    CompositionDropShadowSourcePolicy SourcePolicy { get; set; }
  }
  public sealed class InitialValueExpressionCollection : CompositionObject, IIterable<IKeyValuePair<string, string>>, IMap<string, string>
  public sealed class LayerVisual : ContainerVisual {
    CompositionShadow Shadow { get; set; }
  }
  public class NaturalMotionAnimation : CompositionAnimation
  public sealed class PointLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class ScalarNaturalMotionAnimation : NaturalMotionAnimation
  public sealed class SpotLight : CompositionLight {
    float InnerConeIntensity { get; set; }
    float OuterConeIntensity { get; set; }
  }
  public sealed class SpringScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class SpringVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class SpringVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public class Vector2NaturalMotionAnimation : NaturalMotionAnimation
  public class Vector3NaturalMotionAnimation : NaturalMotionAnimation
}
namespace Windows.UI.Composition.Effects {
  public sealed class SceneLightingEffect : IGraphicsEffect, IGraphicsEffectSource {
    SceneLightingEffectReflectanceModel ReflectanceModel { get; set; }
  }
  public enum SceneLightingEffectReflectanceModel
}
namespace Windows.UI.Composition.Interactions {
  public sealed class InteractionTracker : CompositionObject {
    void ConfigureVector2PositionInertiaModifiers(IIterable<InteractionTrackerVector2InertiaModifier> modifiers);
  }
  public sealed class InteractionTrackerInertiaNaturalMotion : InteractionTrackerInertiaModifier
  public class InteractionTrackerVector2InertiaModifier : CompositionObject
  public sealed class InteractionTrackerVector2InertiaNaturalMotion : InteractionTrackerVector2InertiaModifier
}
namespace Windows.UI.Core {
  public enum CoreCursorType {
    Person = 15,
    Pin = 14,
  }
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    CoreWindowActivationMode ActivationMode { get; }
    DispatcherQueue DispatcherQueue { get; }
  }
  public enum CoreWindowActivationMode
}
namespace Windows.UI.Input {
  public sealed class RadialControllerConfiguration {
    public static RadialController AppController { get; set; }
    public static bool IsAppControllerEnabled { get; set; }
  }
}
namespace Windows.UI.Input.Inking.Core {
  public sealed class CoreIncrementalInkStroke
  public sealed class CoreInkPresenterHost
}
namespace Windows.UI.Input.Preview.Injection {
  public sealed class InjectedInputGamepadInfo
  public sealed class InputInjector {
    void InitializeGamepadInjection();
    void InjectGamepadInput(InjectedInputGamepadInfo input);
    public static InputInjector TryCreateForAppBroadcastOnly();
    void UninitializeGamepadInjection();
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    IAsyncOperation<IRandomAccessStreamWithContentType> TryGetRenderableModelAsync();
  }
  public sealed class SpatialInteractionSource {
    SpatialInteractionSourceHandedness Handedness { get; }
  }
  public enum SpatialInteractionSourceHandedness
  public sealed class SpatialInteractionSourceLocation {
    IReference<Vector3> AngularVelocity { get; }
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
    SpatialPointerInteractionSourcePose SourcePointerPose { get; }
  }
  public enum SpatialInteractionSourcePositionQuality
  public sealed class SpatialPointerInteractionSourcePose {
    Quaternion Orientation { get; }
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
  }
}
namespace Windows.UI.Shell {
  public static class AdaptiveCardBuilder
  public interface IAdaptiveCard
  public interface IAdaptiveCardBuilderStatics
  public sealed class TaskbarManager
}
namespace Windows.UI.StartScreen {
  public sealed class SecondaryTileVisualElements {
    TileMixedRealityModel MixedRealityModel { get; }
  }
  public sealed class TileMixedRealityModel
}
namespace Windows.UI.Text.Core {
  public enum CoreTextInputScope {
    Digits = 28,
    PinAlphanumeric = 65,
    PinNumeric = 64,
  }
}
namespace Windows.UI.ViewManagement {
  public enum UIElementType {
    AccentColor = 1000,
    NonTextHigh = 1005,
    NonTextLow = 1009,
    NonTextMedium = 1007,
    NonTextMediumHigh = 1006,
    NonTextMediumLow = 1008,
    OverlayOutsidePopup = 1012,
    PageBackground = 1010,
    PopupBackground = 1011,
    TextContrastWithHigh = 1004,
    TextHigh = 1001,
    TextLow = 1003,
    TextMedium = 1002,
  }
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView
  public sealed class CoreInputViewOcclusion
  public enum CoreInputViewOcclusionKind
  public sealed class CoreInputViewOcclusionsChangedEventArgs
}
namespace Windows.UI.WebUI {
  public static class WebUIApplication {
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync(string launchArguments);
    public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class WebUICommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class WebUIStartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.UI.Xaml {
  public class FrameworkElement : UIElement {
    ElementTheme ActualTheme { get; }
    public static DependencyProperty ActualThemeProperty { get; }
    event TypedEventHandler<FrameworkElement, object> ActualThemeChanged;
  }
  public enum TextAlignment {
    End = 2,
    Start = 1,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent CharacterReceivedEvent { get; }
    IVector<KeyboardAccelerator> KeyboardAccelerators { get; }
    public static RoutedEvent PreviewKeyDownEvent { get; }
    public static RoutedEvent PreviewKeyUpEvent { get; }
    event TypedEventHandler<UIElement, CharacterReceivedRoutedEventArgs> CharacterReceived;
    event KeyEventHandler PreviewKeyDown;
    event KeyEventHandler PreviewKeyUp;
    event TypedEventHandler<UIElement, ProcessKeyboardAcceleratorEventArgs> ProcessKeyboardAccelerators;
    virtual IIterable<DependencyObject> GetChildrenInTabFocusOrder();
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationNotificationKind
  public enum AutomationNotificationProcessing
  public class AutomationPeer : DependencyObject {
    void RaiseNotificationEvent(AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, string displayString, string activityId);
  }
  public class ColorPickerSliderAutomationPeer : SliderAutomationPeer
  public class ColorSpectrumAutomationPeer : FrameworkElementAutomationPeer
  public class AutomationPeer : ListViewItemAutomationPeer
  public class PersonPictureAutomationPeer : FrameworkElementAutomationPeer
  public class RatingControlAutomationPeer : FrameworkElementAutomationPeer
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class BitmapIconSource : IconSource
  public enum CharacterCasing
  public sealed class ColorChangedEventArgs
  public class ColorPicker : Control
  public enum ColorPickerHsvChannel
  public enum ColorSpectrumComponents
  public enum ColorSpectrumShape
  public class ComboBox : Selector {
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
  }
  public class ContentDialog : ContentControl {
    IAsyncOperation<ContentDialogResult> ShowAsync(ContentDialogPlacement placement);
  }
  public enum ContentDialogPlacement
  public class Control : FrameworkElement {
    virtual void OnCharacterReceived(CharacterReceivedRoutedEventArgs e);
    virtual void OnPreviewKeyDown(KeyRoutedEventArgs e);
    virtual void OnPreviewKeyUp(KeyRoutedEventArgs e);
  }
  public enum DisabledFormattingAccelerators : uint
  public class FontIconSource : IconSource
  public class Grid : Panel {
    double ColumnSpacing { get; set; }
    public static DependencyProperty ColumnSpacingProperty { get; }
    double RowSpacing { get; set; }
    public static DependencyProperty RowSpacingProperty { get; }
  }
  public class IconSource : DependencyObject
  public sealed class IsTextTrimmedChangedEventArgs
  public class MediaTransportControls : Control {
    bool IsRepeatButtonVisible { get; set; }
    public static DependencyProperty IsRepeatButtonVisibleProperty { get; }
    bool IsRepeatEnabled { get; set; }
    public static DependencyProperty IsRepeatEnabledProperty { get; }
    bool ShowAndHideAutomatically { get; set; }
    public static DependencyProperty ShowAndHideAutomaticallyProperty { get; }
    void Hide();
    void Show();
  }
  public class NavigationView : ContentControl
  public enum NavigationViewDisplayMode
  public sealed class NavigationViewDisplayModeChangedEventArgs
  public class NavigationViewItem : NavigationViewItemBase
  public class NavigationViewItemBase : ListViewItem
  public class NavigationViewItemHeader : NavigationViewItemBase
  public sealed class NavigationViewItemInvokedEventArgs
  public class NavigationViewItemSeparator : NavigationViewItemBase
  public class NavigationViewList : ListView
  public sealed class NavigationViewSelectionChangedEventArgs
  public enum ParallaxSourceOffsetKind
  public class ParallaxView : FrameworkElement
  public sealed class PasswordBox : Control {
    event TypedEventHandler<PasswordBox, PasswordBoxPasswordChangingEventArgs> PasswordChanging;
  }
  public sealed class PasswordBoxPasswordChangingEventArgs
  public class PathIconSource : IconSource
  public class PersonPicture : Control
  public class RatingControl : Control
  public class RatingItemFontInfo : RatingItemInfo
  public class RatingItemImageInfo : RatingItemInfo
  public class RatingItemInfo : DependencyObject
  public class RichEditBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    DisabledFormattingAccelerators DisabledFormattingAccelerators { get; set; }
    public static DependencyProperty DisabledFormattingAcceleratorsProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    event TypedEventHandler<RichEditBox, TextControlCopyingToClipboardEventArgs> CopyingToClipboard;
    event TypedEventHandler<RichEditBox, TextControlCuttingToClipboardEventArgs> CuttingToClipboard;
  }
  public sealed class RichTextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector<TextHighlighter> TextHighlighters { get; }
    event TypedEventHandler<RichTextBlock, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
  }
  public sealed class RichTextBlockOverflow : FrameworkElement {
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    event TypedEventHandler<RichTextBlockOverflow, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
  }
  public class SplitView : Control {
    event TypedEventHandler<SplitView, object> PaneOpened;
    event TypedEventHandler<SplitView, object> PaneOpening;
  }
  public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
    double Spacing { get; set; }
    public static DependencyProperty SpacingProperty { get; }
  }
  public enum SwipeBehaviorOnInvoked
  public class SwipeControl : ContentControl
  public class SwipeItem : DependencyObject
  public sealed class SwipeItemInvokedEventArgs
  public class SwipeItems : DependencyObject, IIterable<SwipeItem>, IVector<SwipeItem>
  public enum SwipeMode
  public enum Symbol {
    GlobalNavigationButton = 59136,
    Print = 59209,
    Share = 59181,
    XboxOneConsole = 59792,
  }
  public class SymbolIconSource : IconSource
  public sealed class TextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector<TextHighlighter> TextHighlighters { get; }
    event TypedEventHandler<TextBlock, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
  }
  public class TextBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
    event TypedEventHandler<TextBox, TextBoxBeforeTextChangingEventArgs> BeforeTextChanging;
    event TypedEventHandler<TextBox, TextControlCopyingToClipboardEventArgs> CopyingToClipboard;
    event TypedEventHandler<TextBox, TextControlCuttingToClipboardEventArgs> CuttingToClipboard;
  }
  public sealed class TextBoxBeforeTextChangingEventArgs
  public sealed class TextControlCopyingToClipboardEventArgs
  public sealed class TextControlCuttingToClipboardEventArgs
  public class TreeView : Control
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemClickEventArgs
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject, IBindableIterable, IBindableObservableVector, IBindableVector
  public enum TreeViewSelectionMode
  public sealed class XamlBooleanToVisibilityConverter : IValueConverter
  public sealed class XamlIntegerToIndentationConverter : IValueConverter
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    IVector<MapLayer> Layers { get; set; }
    public static DependencyProperty LayersProperty { get; }
    bool TryGetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
    bool TryGetLocationFromOffset(Point offset, out Geopoint location);
  }
  public class MapElement : DependencyObject {
    string MapStyleSheetEntry { get; set; }
    public static DependencyProperty MapStyleSheetEntryProperty { get; }
    string MapStyleSheetEntryState { get; set; }
    public static DependencyProperty MapStyleSheetEntryStateProperty { get; }
    object Tag { get; set; }
    public static DependencyProperty TagProperty { get; }
  }
  public sealed class MapElement3D : MapElement
  public sealed class MapElementsLayer : MapLayer
  public sealed class MapElementsLayerClickEventArgs
  public sealed class MapElementsLayerContextRequestedEventArgs
  public sealed class MapElementsLayerPointerEnteredEventArgs
  public sealed class MapElementsLayerPointerExitedEventArgs
  public class MapLayer : DependencyObject
  public class MapModel3D : DependencyObject
  public enum MapModel3DShadingOption
  public static class MapStyleSheetEntries
  public static class MapStyleSheetEntryStates
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class ColorPickerSlider : Slider
  public class ColorSpectrum : Control
  public class FlyoutBase : DependencyObject {
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
  public sealed class LayoutInformation {
    public static Size GetAvailableSize(UIElement element);
  }
  public class ListViewItemPresenter : ContentPresenter {
    Brush RevealBackground { get; set; }
    public static DependencyProperty RevealBackgroundProperty { get; }
    bool RevealBackgroundShowsAboveContent { get; set; }
    public static DependencyProperty RevealBackgroundShowsAboveContentProperty { get; }
    Brush RevealBorderBrush { get; set; }
    public static DependencyProperty RevealBorderBrushProperty { get; }
    Thickness RevealBorderThickness { get; set; }
    public static DependencyProperty RevealBorderThicknessProperty { get; }
  }
}
namespace Windows.UI.Xaml.Data {
  public enum UpdateSourceTrigger {
    LostFocus = 3,
  }
}
namespace Windows.UI.Xaml.Documents {
  public class Block : TextElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
  }
  public sealed class Hyperlink : Span {
    bool IsTabStop { get; set; }
    public static DependencyProperty IsTabStopProperty { get; }
    int TabIndex { get; set; }
    public static DependencyProperty TabIndexProperty { get; }
  }
  public class TextHighlighter
  public class TextHighlighterBase : DependencyObject
  public struct TextRange
}
namespace Windows.UI.Xaml.Input {
  public sealed class CharacterReceivedRoutedEventArgs : RoutedEventArgs
  public class KeyboardAccelerator : DependencyObject
  public sealed class KeyboardAcceleratorInvokedEventArgs
  public sealed class PointerRoutedEventArgs : RoutedEventArgs {
    bool IsGenerated { get; }
  }
  public sealed class ProcessKeyboardAcceleratorEventArgs
}
namespace Windows.UI.Xaml.Markup {
  public class MarkupExtension
  public sealed class MarkupExtensionReturnTypeAttribute : Attribute
}
namespace Windows.UI.Xaml.Media {
  public enum AcrylicBackgroundSource
  public class AcrylicBrush : XamlCompositionBrushBase
  public class RevealBackgroundBrush : RevealBrush
  public class RevealBorderBrush : RevealBrush
  public class RevealBrush : XamlCompositionBrushBase
  public enum RevealBrushState
}
namespace Windows.Web {
  public enum WebErrorStatus {
    InsufficientRangeSupport = 22,
    MissingContentLengthSupport = 23,
  }
}
 
namespace Windows.Gaming.Preview.GamesEnumeration {
  public static class GameList {
    public static IAsyncOperation<GameListEntry> MergeEntriesAsync(GameListEntry left, GameListEntry right);
    public static IAsyncOperation<IVectorView<GameListEntry>> UnmergeEntryAsync(GameListEntry mergedEntry);
  }
  public sealed class GameListEntry : IGameListEntry {
    GameModeConfiguration GameModeConfiguration { get; }
    GameListEntryLaunchableState LaunchableState { get; }
    IStorageFile LauncherExecutable { get; }
    string LaunchParameters { get; }
    string TitleId { get; }
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile);
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile, string launchParams);
    IAsyncAction SetTitleIdAsync(string id);
  }
  public enum GameListEntryLaunchableState
  public sealed class GameModeConfiguration
  public sealed class GameModeUserConfiguration
}
 
namespace Windows.Graphics.Printing3D {
  public sealed class Printing3D3MFPackage {
    Printing3DPackageCompression Compression { get; set; }
  }
  public enum Printing3DPackageCompression
}
 
namespace Windows.Media.Capture {
  public sealed class AppBroadcastBackgroundService {
    string BroadcastChannel { get; set; }
    string BroadcastLanguage { get; set; }
    string BroadcastTitle { get; set; }
    event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastChannelChanged;
    event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastLanguageChanged;
    event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastTitleChanged;
  }
  public sealed class AppBroadcastBackgroundServiceSignInInfo {
    event TypedEventHandler<AppBroadcastBackgroundServiceSignInInfo, object> UserNameChanged;
  }
  public sealed class AppBroadcastBackgroundServiceStreamInfo {
    void ReportProblemWithStream();
  }
}
 
namespace Windows.Security.EnterpriseData {
  public sealed class FileProtectionInfo {
    bool IsProtectWhileOpenSupported { get; }
  }
}
 
namespace Windows.Services.Maps.Guidance {
  public sealed class GuidanceRoadSegment {
    bool IsScenic { get; }
  }
}
 
namespace Windows.Services.Maps.LocalSearch {
  public static class PlaceInfoHelper
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControlDataHelper : DependencyObject {
    public static MapControl CreateMapControl(bool rasterRenderMode);
  }
}
 
namespace Windows.System.Profile.SystemManufacturers {
  public sealed class OemSupportInfo
  public static class SystemSupportInfo
}
 
namespace Windows.System {
  public static class DateTimeSettings
}
 
namespace Windows.UI.Xaml.Hosting {
  public sealed class DesignerAppManager : IClosable
  public sealed class DesignerAppView : IClosable
  public enum DesignerAppViewState
  public sealed class ProcessExitedEventArgs
}

Windows 10 SDK Preview Build 15052 Released

Today, we released a new Windows 10 Creators Update SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 15052 or greater). The Preview SDK Build 15052 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 feature requests, head over to our Windows Platform UserVoice.

What’s New

  • No API changes have occurred since build 15021.
  • Windows SDK setup name change: With this release of the Windows SDK the setup executable name changed.  If you have scripts designed to install the previous SDK, you will need to update the path to use the new name:  WinSDKSetup.exe
  • 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 Windows SDK

  • DX12 Template Throws when running Build 15042: This is a known bug in the Windows SDK installer.  If you encounter this issue, you can repair the SDK by simply running the following command from an Administrative command prompt:  C:program files (x86)windows kits10bin10.0.15042.0x86DismFoDInstall.cmd

API Updates and Additions

No API changes have occurred since build 15021. For a list of the APIs added since Windows 10 Anniversary Update, please see 15021.

Windows 10 SDK Preview Build 15042 Released

Today, we released a new Windows 10 Creators Update SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 15042 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 15042 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

What’s New

  • No API changes have occurred since build 15021.
  • Windows SDK setup name change: With this release of the Windows SDK the setup executable name changed.  If you have scripts designed to install the previous SDK, you will need to update the path to use the new name:  WinSDKSetup.exe.
  • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 RC here.

Known Issues Windows SDK

  • DX12 Template Throws when running Build 15042: This is a known bug in the Windows SDK installer.  If you encounter this issue, you can repair the SDK by simply running the following command from an Administrative command prompt:  C:program files (x86)windows kits10bin10.0.15042.0x86DismFoDInstall.cmd
  • Unable to deploy to device:  If you are unable to deploy your app to a device or emulator, it may be because Windows IPOverUSB did not install correctly.  To work around this issue:
    1. Open up the ISO
    2. Navigate into the WindowsSDKInstallers folder
    3. Double click on the file “Windows IP Over USB-x86_en-us.msi”
    4. Follow the prompts
  • Windows App Certification Kit crashes when launched from Visual Studio: If Visual Studio cannot deploy the app, the Windows App Certification Kit may crash when loading.  To work around this issue:
    1. Launch the Windows App Certification Kit from the Windows shortcut
    2. Provide a pointer directly to the package to run the tests

API Updates and Additions

No API changes have occurred since build 15021. For a list of the APIs added since Windows 10 Anniversary Update, please see 15021.

Windows Developer Day – Creators Update

Back in October, Satya, Terry and Panos introduced the Windows 10 Creators Update. They showed some of the new features and announced some amazing new additions to our Surface family of devices. Since then, my team has been working to complete the platform work for the Creators Update to deliver the full power of the Universal Windows Platform to our developers around the world.

Today, I had the chance to host the Windows Developer Day for the Creators Update and to share some of the developer-focused features that are coming soon. You can get started using these today by becoming a Windows Insider and downloading our latest preview SDK, which is now feature complete.

This is an exciting day for me because I love getting to spend time and share information with our developers. We are all driven by our mutual passion to build technology, whether we work on apps for enterprise, games or anything in between.

UWP Improvements

The Universal Windows Platform (UWP) enables your Windows apps to take advantage of the full power of the PC. To show an example of this power, I was joined on stage by Vincent Hardy from Adobe Systems, who showed us Adobe XD, a full-featured and sophisticated desktop application built on UWP.  The Adobe XD app combines beauty and power to deliver a great experience across multiple devices, form factors and input modalities.

We know that many developers want to take full advantage of modern Windows capabilities delivered in UWP, while still retaining their existing technology and code investments. The Desktop Bridge for Windows enables existing desktop applications to call UWP APIs and to be distributed and updated via the Windows Store. The Desktop Bridge makes it easier than ever to share code between Win32, .NET and UWP, taking advantage of the store’s ability to deliver easy and automated upgrades to help ensure that customers are always running the latest and best versions of their apps. Today, I showed Evernote, Photoscape X Pro and KODI, just three of the more than 330 Windows apps and games published to the store in the first four months of availability.

We believe we can work faster and smarter to deliver the best platform for developers if we work with the community. To do just this, I announced that we will make all Microsoft developer documents available and open for community collaboration. In addition, we will open our bug and feature backlog to the public and take bug contributions and feature requests starting today at noon.

In that spirit of openness, I was joined on stage by Todd Anglin from Progress, makers of the powerful Telerik controls. Telerik is popular with enterprise developers, enabling them to build great business applications with a rich set of easy-to-use UI controls. Todd showed us what these great controls can do, and announced that they are now Open Source and available on GitHub and also as NuGet packages. Find out more at telerik.com/uwp.

One of the great powers of UWP is its ability to run across a wide range of Windows devices and enable a wide range of experiences. Today, I showed a few examples of this ability:

  • Developers will be able to use the Windows Holographic Platform to bring amazing 3D experiences, both apps and games, not just to HoloLens, but to the wide range of mixed-reality headsets coming soon. We showed how easy it is to make a single app look fantastic across HoloLens and occluded headsets.
  • The new Cortana Skills Kit gives developers new and natural ways to connect user to their apps and services. We built a Cortana Skill on stage today and showed how easy it is to integrate bots created using the Microsoft Bot Framework and LUIS.
  • We know that your users interact with a variety of devices throughout the day, so we are building UWP capabilities (called “Project Rome”) to help your experiences flow seamlessly across devices, and guide users to your best and richest experience. Rome provides “apps for websites”, a simple tool that directs users to your apps (with the right context) rather than simply opening the browser. Rome’s cross-device services make it easy for users to continue an activity within your app as they move from one device to another, including Android devices. To make this possible, we released today the Rome SDK for Android.

Whenever I talk to developers, I hear that it is critically important for us to enable you to build apps that are visually beautiful and engaging, and that also take advantage of the latest and coolest hardware capabilities. It is also a high priority for us. Today, I showed some of the new capabilities that are coming to the visual and XAML layers of the platform that enable you to create beautiful user experiences through the use of effects, animations and transitions. With only a small amount of code, you can bring these effects to your apps with amazing results that delight users. In the Creators Update, we have worked to deliver new capabilities in pen and ink, including a more powerful ink toolbar that’s easy for any developer to use; smart ink, which enables recognition of lists, simple shapes and even math symbols; and enhanced APIs that enable you to do more than ever with the Surface Dial. Check out the video of the presentation for a full demo that shows a lot of these features coming together to make a beautiful and engaging app.

Games on UWP

I talked a lot about apps, but we’re also building UWP to be the best platform for building amazing games that run across the PC and Xbox One. With the Creators Update, UWP makes game development faster, easier and better. Specifically, I’d like to call out three key UWP improvements that will be appreciated by gamers and devs alike:

  • Game Mode: Windows 10 can optimize system resources to deliver the best PC gaming experience possible.
  • UWP on Xbox: UWP games (along with apps) will now be available on Xbox One via the Windows Store.
  • Windows Sonic: Microsoft’s next-gen spatial audio platform provides a powerful, immersive sound experience with support for Dolby Atmos. Windows Sonic will be available on Xbox One and Windows 10 PCs, also supporting both speakers and headphones.
  • Intelligent install: Lastly, the UWP packaging format makes it easier to install the bits in the right order, letting players jump into a new game (or app) before it has fully downloaded. And updates focus on downloading only the bits that have changed, so players can jump back in even faster.

For more information on these features and many more coming this year, tune into the Xbox sessions at GDC in a few weeks.

Windows is the home for all developers

I’m a developer, and my team is a team of developers. Like you, we love our tools and services and we’re very demanding of them. We want Windows to be the very best place to develop experiences, whether for Windows, the web or cross-platform. Today, we showed some of the performance, stability and debugging improvements in Visual Studio 2017. We demonstrated improvements to the Console and Bash, as well as to the Windows Subsystem for Linux. We showed remote access to device information via the Windows Device Portal, and even pixel-level GPU debugging with the new PIX tool for Windows.

The Windows Store team walked through several new and improved services coming in the next few months. Store Services APIs provide services to help you understand how your app is performing in the wild, including analytics and telemetry, flighting, automated submissions and updates, and ad campaigns.  The team also highlighted updated services to enable better user engagement using A/B testing, targeted push notifications and more.

And, of course, I recognize that you use lots of services from providers other than Microsoft, so today it gave me great pleasure to show powerful additions to the collection of middleware that is available to Windows Developers. Today, we announced the immediate availability to two important libraries:

  • The Windows SDK for Google Analytics brings one of the most popular and powerful real-time analytics packages to Windows. The core library works with UWP, Xamarin, Windows Forms and WPF, allowing for maximum code reuse.
  • Facebook App Install Ads are now available for UWP apps. Facebook App Install Ads are displayed in the Facebook newsfeed both on the web and in the Facebook app, bringing immense reach to Windows developers, as well as rich targeting capabilities (including interests, location and demographics) and their ads manager dashboard.

Where to get the bits

Here’s a quick recap of some of the announcements we made today:

  • Windows SDK Availability: Become a Windows Insider and get the newest feature-complete flight of the Windows 10 Creators Update SDK today.
  • Documentation: For the first time, all of Microsoft’s developer documentation will be in one place (http://docs.microsoft.com/) where it will be easier to find and use. We are also opening up the docs to community contribution.
  • Developer Platform Backlog: My team and I are making our backlog public, for both features and bugs. This will be online at noon today at https://developer.microsoft.com/windows/platform.
  • Telerik Controls: The Telerik UWP control library is now open source and available on GitHub and as NuGet packages. Find out more at telerik.com/uwp.
  • Cortana Skills Kit: The Cortana Skills Kit will enter open Developer Preview later this month.
  • Rome SDK for Android: This is a new SDK that brings the cross-devices services of “Project Rome” to Android devices, allowing easy and powerful integration with Windows. Find the new SDK at https://github.com/Microsoft/project-rome.
  • UWP Community Toolkit 1.3: Today, we are releasing a big update to the toolkit that includes many contributions from our developer community.
  • Windows SDK for Google Analytics: This new SDK, available now, enables Windows developers (UMP, Xamarin, WPF and WinForms) access to one of the more popular and powerful real-time analytics suites. Get this today at https://github.com/dotnet/windows-sdk-for-google-analytics.
  • Windows SDK for Facebook: With one billion users, Facebook offers one of the most powerful tools for you to acquire new users for your app or game. Check out the new SDK here: https://developers.facebook.com/docs/app-ads/windows-sdk.

It was a great day today, and there is more to come. We look forward to seeing you at Build in a few months when we will go deeper into the Creators Update capabilities for developers, and take a look at what’s coming next. In the meantime, I’d like to invite all of you to get started developing for Windows Creators Update today. Download the SDK, update your applications with new features (or build all-new apps that deliver the best new experiences), and please keep giving us feedback.

— Kevin

Windows 10 SDK Preview Build 15003 Released

Today, we released a new Windows 10 Creators Update SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 15003 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 15003 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Things to Note:

What’s New:

Known Issues Windows SDK:

  • There is no Emulator with this release
  • I cannot specify the new SDK version 15003 when creating a new project
    This version of the SDK only works with Visual Studio 2017.  You can download the Visual Studio 2017 Preview. If you install the latest version Visual Studio 2017, you will be able to specify the build 15003.

API Updates and Additions:

The following API changes are under development and new or updated for this release of the SDK.

namespace Windows.ApplicationModel.Preview.Notes {
  public sealed class NotesWindowManagerPreview {
    void SetFocusToPreviousView();
    IAsyncAction SetThumbnailImageForTaskSwitcherAsync(SoftwareBitmap bitmap);
    void ShowNoteRelativeTo(int noteViewId, int anchorNoteViewId, NotesWindowManagerPreviewShowNoteOptions options);
    void ShowNoteWithPlacement(int noteViewId, IBuffer data, NotesWindowManagerPreviewShowNoteOptions options);
  }
  public sealed class NotesWindowManagerPreviewShowNoteOptions
}
namespace Windows.Devices.Gpio {
  public struct GpioChangeCount
  public sealed class GpioChangeCounter : IClosable
  public enum GpioChangePolarity
  public sealed class GpioChangeReader : IClosable
  public struct GpioChangeRecord
  public enum GpioOpenStatus {
    MuxingConflict = 3,
    UnknownError = 4,
  }
}
namespace Windows.Devices.I2c {
  public enum I2cTransferStatus {
    ClockStretchTimeout = 3,
    UnknownError = 4,
  }
}
namespace Windows.Devices.Pwm {
  public sealed class PwmController {
    public static IAsyncOperation<PwmController> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
    public static string GetDeviceSelector(string friendlyName);
  }
}
namespace Windows.Devices.SmartCards {
  public sealed class SmartCardTriggerDetails {
    SmartCard SmartCard { get; }
  }
}
namespace Windows.Devices.SmartCards {
  public enum SmartCardCryptogramAlgorithm {
    Sha256Hmac = 8,
  }
  public sealed class SmartCardCryptogramGenerator {
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult> GetAllCryptogramMaterialCharacteristicsAsync(SmartCardUnlockPromptingBehavior promptingBehavior, string materialPackageName);
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync();
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync(string storageKeyName);
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult> GetAllCryptogramStorageKeyCharacteristicsAsync();
    IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> ValidateRequestApduAsync(SmartCardUnlockPromptingBehavior promptingBehavior, IBuffer apduToValidate, IIterable<SmartCardCryptogramPlacementStep> cryptogramPlacementSteps);
  }
  public enum SmartCardCryptogramGeneratorOperationStatus {
    ValidationFailed = 12,
  }
  public sealed class SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult
  public sealed class SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult
  public sealed class SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult
  public sealed class SmartCardCryptogramMaterialCharacteristics
  public sealed class SmartCardCryptogramMaterialPackageCharacteristics
  public enum SmartCardCryptogramMaterialProtectionMethod
  public sealed class SmartCardCryptogramStorageKeyCharacteristics
}
namespace Windows.Foundation.Metadata {
  public sealed class FeatureAttribute : Attribute
  public enum FeatureStage
}
namespace Windows.ApplicationModel {
  public sealed class Package {
    IAsyncOperation<PackageContentGroup> GetContentGroupAsync(string name);
    IAsyncOperation<IVector<PackageContentGroup>> GetContentGroupsAsync();
    IAsyncOperation<bool> SetInUseAsync(bool inUse);
    IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names);
    IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names, bool moveToHeadOfQueue);
  }
  public sealed class PackageCatalog {
    event TypedEventHandler<PackageCatalog, PackageContentGroupStagingEventArgs> PackageContentGroupStaging;
    IAsyncOperation<PackageCatalogAddOptionalPackageResult> AddOptionalPackageAsync(string optionalPackageFamilyName);
  }
  public sealed class PackageCatalogAddOptionalPackageResult
  public sealed class PackageContentGroup
  public sealed class PackageContentGroupStagingEventArgs
  public enum PackageContentGroupState
  public sealed class PackageStatus {
    bool IsPartiallyStaged { get; }
  }
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    ContactPanel = 1017,
    LockScreenComponent = 1016,
  }
  public sealed class ContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
  public interface IContactPanelActivatedEventArgs
  public sealed class LockScreenComponentActivatedEventArgs : IActivatedEventArgs
  public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IToastNotificationActivatedEventArgs {
    int CurrentlyShownApplicationViewId { get; }
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class BackgroundTaskBuilder {
    BackgroundTaskRegistrationGroup TaskGroup { get; set; }
  }
  public sealed class BackgroundTaskRegistration : IBackgroundTaskRegistration, IBackgroundTaskRegistration2, IBackgroundTaskRegistration3 {
    public static IMapView<string, BackgroundTaskRegistrationGroup> AllTaskGroups { get; }
    BackgroundTaskRegistrationGroup TaskGroup { get; }
    public static BackgroundTaskRegistrationGroup GetTaskGroup(string groupId);
  }
  public sealed class BackgroundTaskRegistrationGroup
  public sealed class GattCharacteristicNotificationTrigger : IBackgroundTrigger {
    public GattCharacteristicNotificationTrigger(GattCharacteristic characteristic, BluetoothEventTriggeringMode eventTriggeringMode);
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
  }
  public sealed class GattServiceProviderTrigger : IBackgroundTrigger
  public sealed class GattServiceProviderTriggerResult
  public interface IBackgroundTaskRegistration3 : IBackgroundTaskRegistration
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactAnnotation {
    string ContactListId { get; set; }
  }
  public enum ContactAnnotationOperations : uint {
    Share = (uint)32,
  }
  public sealed class ContactAnnotationStore {
    IAsyncOperation<IVectorView<ContactAnnotation>> FindAnnotationsForContactListAsync(string contactListId);
  }
  public sealed class ContactGroup
  public static class ContactManager {
    public static bool IncludeMiddleNameInSystemDisplayAndSort { get; set; }
    public static IAsyncOperation<bool> IsShowFullContactCardSupportedAsync();
  }
  public sealed class ContactManagerForUser {
    void ShowFullContactCard(Contact contact, FullContactCardOptions fullContactCardOptions);
  }
  public sealed class ContactPanel
  public sealed class ContactPanelClosingEventArgs
  public sealed class ContactPanelLaunchFullAppRequestedEventArgs
  public sealed class ContactPicker {
    User User { get; }
    public static ContactPicker CreateForUser(User user);
    public static IAsyncOperation<bool> IsSupportedAsync();
  }
  public sealed class PinnedContactIdsQueryResult
  public sealed class PinnedContactManager
  public enum PinnedContactSurface
}
namespace Windows.ApplicationModel.Core {
  public sealed class CoreApplicationView {
    IPropertySet Properties { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackage {
    event TypedEventHandler<DataPackage, ShareCompletedEventArgs> ShareCompleted;
  }
  public sealed class DataTransferManager {
    event TypedEventHandler<DataTransferManager, ShareProvidersRequestedEventArgs> ShareProvidersRequested;
  }
  public sealed class ShareCompletedEventArgs
  public sealed class SharePeople
  public sealed class ShareProvider
  public delegate void ShareProviderHandler(ShareProviderRequest request);
  public sealed class ShareProviderRequest
  public sealed class ShareProvidersRequestedEventArgs
  public sealed class ShareTargetInfo
}
namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
  public sealed class ShareOperation {
    SharePeople People { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMessage {
    IVector<EmailRecipient> ReplyTo { get; }
    EmailRecipient SentRepresenting { get; set; }
  }
}
namespace Windows.ApplicationModel.Payments {
  public sealed class PaymentAddress
  public sealed class PaymentCurrencyAmount
  public sealed class PaymentDetails
  public sealed class PaymentDetailsModifier
  public sealed class PaymentItem
  public sealed class PaymentMediator
  public sealed class PaymentMerchantInfo
  public sealed class PaymentMethodData
  public enum PaymentOptionPresence
  public sealed class PaymentOptions
  public sealed class PaymentRequest
  public sealed class PaymentRequestChangedArgs
  public delegate void PaymentRequestChangedHandler(PaymentRequest paymentRequest, PaymentRequestChangedArgs args);
  public sealed class PaymentRequestChangedResult
  public enum PaymentRequestChangeKind
  public enum PaymentRequestCompletionStatus
  public enum PaymentRequestStatus
  public sealed class PaymentRequestSubmitResult
  public sealed class PaymentResponse
  public sealed class PaymentShippingOption
  public enum PaymentShippingType
  public sealed class PaymentToken
}
namespace Windows.ApplicationModel.Payments.Provider {
  public sealed class PaymentAppManager
  public sealed class PaymentTransaction
  public sealed class PaymentTransactionAcceptResult
}
namespace Windows.ApplicationModel.Preview.Holographic {
  public static class HolographicApplicationPreview
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
  public static class LicenseManager {
    public static IAsyncAction RefreshLicensesAsync(LicenseRefreshOption refreshOption);
  }
  public enum LicenseRefreshOption
}
namespace Windows.ApplicationModel.Store.Preview {
  public static class StoreConfiguration {
    public static string GetEnterpriseStoreWebAccountId();
    public static string GetEnterpriseStoreWebAccountIdForUser(User user);
    public static string GetStoreWebAccountId();
    public static string GetStoreWebAccountIdForUser(User user);
    public static void SetEnterpriseStoreWebAccountId(string webAccountId);
    public static void SetEnterpriseStoreWebAccountIdForUser(User user, string webAccountId);
    public static bool ShouldRestrictToEnterpriseStoreOnly();
    public static bool ShouldRestrictToEnterpriseStoreOnlyForUser(User user);
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallManager {
    IAsyncOperation<GetEntitlementResult> GetFreeDeviceEntitlementAsync(string storeId, string campaignId, string correlationVector);
    IAsyncOperation<GetEntitlementResult> GetFreeUserEntitlementAsync(string storeId, string campaignId, string correlationVector);
    IAsyncOperation<GetEntitlementResult> GetFreeUserEntitlementForUserAsync(User user, string storeId, string campaignId, string correlationVector);
  }
  public sealed class GetEntitlementResult
  public enum GetEntitlementStatus
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity
  public sealed class UserActivityChannel
  public sealed class UserActivitySession : IClosable
  public enum UserActivityState
  public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
  public static class CoreUserActivityManager
}
namespace Windows.ApplicationModel.UserDataAccounts {
  public sealed class UserDataAccount {
    bool CanShowCreateContactGroup { get; set; }
    IRandomAccessStreamReference Icon { get; set; }
    bool IsProtectedUnderLock { get; set; }
    IPropertySet ProviderProperties { get; }
    IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
    IAsyncOperation<IVectorView<UserDataTaskList>> FindUserDataTaskListsAsync();
    IAsyncOperation<string> TryShowCreateContactGroupAsync();
  }
  public sealed class UserDataAccountStore {
    IAsyncOperation<UserDataAccount> CreateAccountAsync(string userDisplayName, string packageRelativeAppId, string enterpriseId);
  }
}
namespace Windows.ApplicationModel.UserDataTasks {
  public sealed class UserDataTask
  public sealed class UserDataTaskBatch
  public enum UserDataTaskDaysOfWeek : uint
  public enum UserDataTaskDetailsKind
  public enum UserDataTaskKind
  public sealed class UserDataTaskList
  public sealed class UserDataTaskListLimitedWriteOperations
  public enum UserDataTaskListOtherAppReadAccess
  public enum UserDataTaskListOtherAppWriteAccess
  public sealed class UserDataTaskListSyncManager
  public enum UserDataTaskListSyncStatus
  public sealed class UserDataTaskManager
  public enum UserDataTaskPriority
  public enum UserDataTaskQueryKind
  public sealed class UserDataTaskQueryOptions
  public enum UserDataTaskQuerySortProperty
  public sealed class UserDataTaskReader
  public sealed class UserDataTaskRecurrenceProperties
  public enum UserDataTaskRecurrenceUnit
  public sealed class UserDataTaskRegenerationProperties
  public enum UserDataTaskRegenerationUnit
  public enum UserDataTaskSensitivity
  public sealed class UserDataTaskStore
  public enum UserDataTaskStoreAccessType
  public enum UserDataTaskWeekOfMonth
}
namespace Windows.ApplicationModel.UserDataTasks.DataProvider {
  public sealed class UserDataTaskDataProviderConnection
  public sealed class UserDataTaskDataProviderTriggerDetails
  public sealed class UserDataTaskListCompleteTaskRequest
  public sealed class UserDataTaskListCompleteTaskRequestEventArgs
  public sealed class UserDataTaskListCreateOrUpdateTaskRequest
  public sealed class UserDataTaskListCreateOrUpdateTaskRequestEventArgs
  public sealed class UserDataTaskListDeleteTaskRequest
  public sealed class UserDataTaskListDeleteTaskRequestEventArgs
  public sealed class UserDataTaskListSkipOccurrenceRequest
  public sealed class UserDataTaskListSkipOccurrenceRequestEventArgs
  public sealed class UserDataTaskListSyncManagerSyncRequest
  public sealed class UserDataTaskListSyncManagerSyncRequestEventArgs
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter
  public enum BluetoothAddressType {
    Unspecified = 2,
  }
  public sealed class BluetoothDeviceId
  public enum BluetoothError {
    TransportNotSupported = 9,
  }
  public sealed class BluetoothLEDevice : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync();
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(GattUuid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
  }
}
namespace Windows.Devices.Bluetooth.Background {
  public enum BluetoothEventTriggeringMode
 public sealed class GattCharacteristicNotificationTriggerDetails {
    BluetoothError Error { get; }
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
    IVectorView<GattValueChangedEventArgs> ValueChangedEvents { get; }
  }
  public sealed class GattServiceProviderConnection
  public sealed class GattServiceProviderTriggerDetails
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattCharacteristic {
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync();
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(GattUuid descriptorUuid);
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(GattUuid descriptorUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattWriteResult> WriteClientCharacteristicConfigurationDescriptorWithResultAsync(GattClientCharacteristicConfigurationDescriptorValue clientCharacteristicConfigurationDescriptorValue);
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value, GattWriteOption writeOption);
  }
  public sealed class GattCharacteristicsResult
  public sealed class GattClientNotificationResult
  public enum GattCommunicationStatus {
    ProtocolError = 2,
  }
  public sealed class GattDescriptor {
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
  }
 public sealed class GattDescriptorsResult
  public sealed class GattDeviceService : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    GattSession Session { get; }
    GattSharingMode SharingMode { get; }
    public static IAsyncOperation<GattDeviceService> FromIdAsync(string deviceId, GattSharingMode sharingMode);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync();
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(GattUuid characteristicUuid);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(GattUuid characteristicUuid, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelector(GattUuid gattUuid);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync();
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(GattUuid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattOpenStatus> OpenAsync(GattSharingMode sharingMode);
    IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
  }
  public sealed class GattDeviceServicesResult
  public sealed class GattLocalCharacteristic
  public sealed class GattLocalCharacteristicParameters
  public sealed class GattLocalCharacteristicResult
  public sealed class GattLocalDescriptor
  public sealed class GattLocalDescriptorParameters
  public sealed class GattLocalDescriptorResult
  public sealed class GattLocalService
  public enum GattOpenStatus
  public sealed class GattPresentationFormat {
    public static GattPresentationFormat FromParts(byte formatType, int exponent, ushort unit, byte namespaceId, ushort description);
  }
  public static class GattProtocolError
  public sealed class GattReadClientCharacteristicConfigurationDescriptorResult {
    IReference<byte> ProtocolError { get; }
  }
  public sealed class GattReadRequest
  public sealed class GattReadRequestedEventArgs
  public sealed class GattReadResponse
  public sealed class GattReadResult {
    IReference<byte> ProtocolError { get; }
  }
  public sealed class GattReliableWriteTransaction {
    IAsyncOperation<GattWriteResult> CommitWithResultAsync();
  }
  public enum GattRequestState
  public sealed class GattRequestStateChangedEventArgs
  public sealed class GattServiceProvider
  public enum GattServiceProviderAdvertisementStatus
  public sealed class GattServiceProviderAdvertisementStatusChangedEventArgs
  public sealed class GattServiceProviderAdvertisingParameters
  public sealed class GattServiceProviderResult
  public sealed class GattSession : IClosable
  public enum GattSessionStatus
  public sealed class GattSessionStatusChangedEventArgs
  public enum GattSharingMode
  public sealed class GattSubscribedClient
  public sealed class GattUuid
  public sealed class GattWriteRequest
  public sealed class GattWriteRequestedEventArgs
  public sealed class GattWriteResponse
  public sealed class GattWriteResult
}
namespace Windows.Devices.Haptics {
  public static class KnownSimpleHapticsControllerWaveforms
  public sealed class SimpleHapticsController
  public sealed class SimpleHapticsControllerFeedback
  public enum VibrationAccessStatus
  public sealed class VibrationDevice
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScanner : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public static class BarcodeSymbologies {
    public static uint Gs1DWCode { get; }
  }
  public sealed class BarcodeSymbologyAttributes
  public enum BarcodeSymbologyDecodeLengthKind
  public sealed class CashDrawer : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    IAsyncOperation<BarcodeSymbologyAttributes> GetSymbologyAttributesAsync(uint barcodeSymbology);
    IAsyncOperation<bool> SetSymbologyAttributesAsync(uint barcodeSymbology, BarcodeSymbologyAttributes attributes);
  }
  public sealed class ClaimedLineDisplay : IClosable
  public sealed class LineDisplay : IClosable
  public sealed class LineDisplayCapabilities
  public enum LineDisplayScrollDirection
  public enum LineDisplayTextAttribute
  public enum LineDisplayTextAttributeGranularity
  public sealed class LineDisplayWindow : IClosable
  public sealed class MagneticStripeReader : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public enum PosConnectionTypes : uint
  public sealed class PosPrinter : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
}
namespace Windows.Gaming.Input {
  public sealed class ArcadeStick : IGameController, IGameControllerBatteryInfo {
    public static ArcadeStick FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class FlightStick : IGameController, IGameControllerBatteryInfo
  public enum FlightStickButtons : uint
  public struct FlightStickReading
  public enum GameControllerSwitchKind
  public enum GameControllerSwitchPosition
  public sealed class Gamepad : IGameController, IGameControllerBatteryInfo {
    public static Gamepad FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class Headset : IGameControllerBatteryInfo {
    BatteryReport TryGetBatteryReport();
  }
  public interface IGameControllerBatteryInfo
  public sealed class RacingWheel : IGameController, IGameControllerBatteryInfo {
    public static RacingWheel FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class RawGameController : IGameController, IGameControllerBatteryInfo
  public sealed class UINavigationController : IGameController, IGameControllerBatteryInfo {
    public static UINavigationController FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.Gaming.Input.Custom {
  public static class GameControllerFactoryManager {
    public static IGameController TryGetFactoryControllerFromGameController(ICustomGameControllerFactory factory, IGameController gameController);
  }
  public sealed class HidGameControllerProvider : IGameControllerProvider
  public interface IHidGameControllerInputSink : IGameControllerInputSink
}
namespace Windows.Gaming.UI {
  public enum GameChatMessageOrigin
  public sealed class GameChatOverlay
  public enum GameChatOverlayPosition
}
namespace Windows.Globalization {
  public static class CurrencyIdentifiers {
    public static string BYN { get; }
  }
}
namespace Windows.Globalization.Collation {
  public sealed class CharacterGroupings : IIterable<CharacterGrouping>, IVectorView<CharacterGrouping> {
    public CharacterGroupings(string language);
  }
}
namespace Windows.Graphics {
  public struct PointInt32
  public struct RectInt32
  public struct SizeInt32
}
namespace Windows.Graphics.Display.Core {
  public enum HdmiDisplayColorSpace
  public struct HdmiDisplayHdr2086Metadata
  public enum HdmiDisplayHdrOption
  public sealed class HdmiDisplayInformation
  public sealed class HdmiDisplayMode
  public enum HdmiDisplayPixelEncoding
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    HolographicDisplay Display { get; }
    HolographicCameraViewportParameters LeftViewportParameters { get; }
    HolographicCameraViewportParameters RightViewportParameters { get; }
  }
  public sealed class HolographicCameraRenderingParameters {
    HolographicReprojectionMode ReprojectionMode { get; set; }
    void CommitDirect3D11DepthBuffer(IDirect3DSurface value);
  }
  public sealed class HolographicCameraViewportParameters
  public sealed class HolographicDisplay
  public enum HolographicReprojectionMode
  public sealed class HolographicSpace {
    public static bool IsAvailable { get; }
    public static bool IsSupported { get; }
    public static event EventHandler<object> IsAvailableChanged;
  }
}
namespace Windows.Graphics.Printing.PrintTicket {
  public sealed class PrintTicketCapabilities
  public sealed class PrintTicketFeature
  public enum PrintTicketFeatureSelectionType
  public sealed class PrintTicketOption
  public enum PrintTicketParameterDataType
  public sealed class PrintTicketParameterDefinition
  public sealed class PrintTicketParameterInitializer
  public sealed class PrintTicketValue
  public enum PrintTicketValueType
  public sealed class WorkflowPrintTicket
  public sealed class WorkflowPrintTicketValidationResult
}
namespace Windows.Graphics.Printing.Workflow {
  public sealed class ObjectModelSourceFileContent
  public sealed class PrintWorkflowBackgroundSession
  public sealed class PrintWorkflowBackgroundSetupRequestedEventArgs
  public sealed class PrintWorkflowConfiguration
  public sealed class PrintWorkflowContext
  public sealed class PrintWorkflowForegroundSession
  public sealed class PrintWorkflowForegroundSetupRequestedEventArgs
  public enum PrintWorkflowSessionStatus
  public sealed class PrintWorkflowSourceContent
  public sealed class PrintWorkflowSpoolStreamContent
  public sealed class PrintWorkflowStreamTarget
  public sealed class PrintWorkflowSubmittedEventArgs
  public sealed class PrintWorkflowSubmittedOperation
  public enum PrintWorkflowSubmittedStatus
  public sealed class PrintWorkflowTarget
  public sealed class PrintWorkflowUIActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser
  public sealed class PrintWorkflowXpsDataAvailableEventArgs
  public sealed class WorkflowTriggerDetails
  public sealed class XpsObjectModelTargetPackage
}
namespace Windows.Management {
  public sealed class MdmAlert
  public enum MdmAlertDataType
  public enum MdmAlertMark
  public sealed class MdmSession
  public static class MdmSessionManager
  public enum MdmSessionState
}
namespace Windows.Management.Deployment {
  public enum DeploymentOptions : uint {
    RequiredContentGroupOnly = (uint)256,
  }
  public sealed class DeploymentResult {
    bool IsRegistered { get; }
  }
  public sealed class PackageManager {
    PackageManagerDebugSettings DebugSettings { get; }
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RegisterPackageByFamilyNameAsync(string mainPackageFamilyName, IIterable<string> dependencyPackageFamilyNames, DeploymentOptions deploymentOptions, PackageVolume appDataVolume, IIterable<string> optionalPackageFamilyNames);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
  }
  public sealed class PackageManagerDebugSettings
}
namespace Windows.Management.Policies {
  public static class AboveLockPolicies
  public static class AccountsPolicies
  public static class AppHvsiPolicies
  public static class ApplicationManagementPolicies
  public sealed class ApplicationManagementPoliciesForUser
  public static class AuthenticationPolicies
  public sealed class AuthenticationPoliciesForUser
  public sealed class BinaryPolicy
  public static class BitlockerPolicies
  public static class BluetoothPolicies
  public sealed class BooleanPolicy
  public static class BrowserPolicies
  public static class CameraPolicies
  public static class ConnectivityPolicies
  public static class CryptographyPolicies
  public static class DataProtectionPolicies
  public static class DefenderPolicies
  public static class DeliveryOptimizationPolicies
  public static class DeviceLockPolicies
  public static class ExperiencePolicies
  public sealed class ExperiencePoliciesForUser
  public sealed class Int32Policy
  public static class LicensingPolicies
  public static class LockDownPolicies
  public static class MapsPolicies
  public static class MessagingPolicies
  public static class NamedPolicy
  public sealed class NamedPolicyData
  public enum NamedPolicyKind
  public static class NetworkIsolationPolicies
  public static class NotificationsPolicies
  public sealed class NotificationsPoliciesForUser
  public static class PrivacyPolicies
  public static class SearchPolicies
  public static class SecurityPolicies
  public static class SettingsPolicies
  public static class SpeechPolicies
  public static class StartPolicies
  public sealed class StartPoliciesForUser
  public sealed class StringPolicy
  public static class SystemPolicies
  public static class TextInputPolicies
  public static class UpdatePolicies
  public static class WiFiPolicies
  public static class WindowsInkWorkspacePolicies
  public static class WirelessDisplayPolicies
}
namespace Windows.Media {
  public sealed class MediaExtensionManager {
    void RegisterMediaExtensionForAppService(IMediaExtension extension, AppServiceConnection connection);
  }
  public sealed class MediaTimelineController {
    IReference<TimeSpan> Duration { get; set; }
    bool IsLoopingEnabled { get; set; }
    event TypedEventHandler<MediaTimelineController, object> Ended;
    event TypedEventHandler<MediaTimelineController, MediaTimelineControllerFailedEventArgs> Failed;
  }
  public sealed class MediaTimelineControllerFailedEventArgs
  public enum MediaTimelineControllerState {
    Error = 3,
    Stalled = 2,
  }
  public struct MediaTimeRange
}
namespace Windows.Media.Capture {
  public sealed class MediaCapture : IClosable {
    event TypedEventHandler<MediaCapture, MediaCaptureDeviceExclusiveControlStatusChangedEventArgs> CaptureDeviceExclusiveControlStatusChanged;
  }
  public enum MediaCaptureDeviceExclusiveControlStatus
  public sealed class MediaCaptureDeviceExclusiveControlStatusChangedEventArgs
  public sealed class MediaCaptureInitializationSettings {
    bool AlwaysPlaySystemShutterSound { get; set; }
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class DepthMediaFrame {
    uint MaxReliableDepth { get; }
    uint MinReliableDepth { get; }
  }
  public enum MediaFrameReaderStartStatus {
    ExclusiveControlNotAvailable = 4,
  }
}
namespace Windows.Media.Core {
  public enum AudioDecoderDegradationReason {
    SpatialAudioNotSupported = 2,
  }
  public sealed class ChapterCue : IMediaCue
  public enum CodecCategory
  public sealed class CodecInfo
  public enum CodecKind
  public sealed class CodecQuery
  public static class CodecSubtypes
  public sealed class DataCue : IMediaCue {
    PropertySet Properties { get; }
  }
  public sealed class ImageCue : IMediaCue
  public interface ITimedMetadataTrackProvider
  public sealed class MediaBindingEventArgs {
    void SetAdaptiveMediaSource(AdaptiveMediaSource mediaSource);
    void SetStorageFile(IStorageFile file);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    AdaptiveMediaSource AdaptiveMediaSource { get; }
    MediaStreamSource MediaStreamSource { get; }
    MseStreamSource MseStreamSource { get; }
    Uri Uri { get; }
    IAsyncAction OpenAsync();
  }
  public sealed class MediaStreamSource : IMediaSource {
    IReference<double> MaxSupportedPlaybackRate { get; set; }
  }
  public sealed class SpeechCue : IMediaCue
  public enum TimedMetadataKind {
    ImageSubtitle = 6,
    Speech = 7,
  }
  public enum TimedTextFontStyle
  public sealed class TimedTextSource {
    public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream);
    public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream, string defaultLanguage);
    public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri);
    public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri, string defaultLanguage);
  }
  public sealed class TimedTextStyle {
    TimedTextFontStyle FontStyle { get; set; }
    bool IsLineThroughEnabled { get; set; }
    bool IsOverlineEnabled { get; set; }
    bool IsUnderlineEnabled { get; set; }
  }
}
namespace Windows.Media.Core.Preview {
  public static class SoundLevelBroker
}
namespace Windows.Media.Devices {
  public sealed class AudioDeviceModule
  public sealed class AudioDeviceModuleNotificationEventArgs
  public sealed class AudioDeviceModulesManager
  public sealed class ModuleCommandResult
  public enum SendCommandStatus
  public sealed class VideoDeviceController : IMediaDeviceController {
    string Id { get; }
  }
}
namespace Windows.Media.MediaProperties {
  public sealed class AudioEncodingProperties : IMediaEncodingProperties {
    bool IsSpatial { get; }
    public static AudioEncodingProperties CreateAlac(uint sampleRate, uint channelCount, uint bitsPerSample);
    public static AudioEncodingProperties CreateFlac(uint sampleRate, uint channelCount, uint bitsPerSample);
  }
  public sealed class MediaEncodingProfile {
    public static MediaEncodingProfile CreateAlac(AudioEncodingQuality quality);
    public static MediaEncodingProfile CreateFlac(AudioEncodingQuality quality);
    public static MediaEncodingProfile CreateHevc(VideoEncodingQuality quality);
  }
  public static class MediaEncodingSubtypes {
    public static string Alac { get; }
    public static string D16 { get; }
    public static string Flac { get; }
    public static string L16 { get; }
    public static string L8 { get; }
    public static string Vp9 { get; }
  }
  public enum SphericalVideoFrameFormat
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    SphericalVideoFrameFormat SphericalVideoFrameFormat { get; }
    public static VideoEncodingProperties CreateHevc();
  }
  public enum VideoEncodingQuality {
    Uhd2160p = 8,
    Uhd4320p = 9,
  }
}
namespace Windows.Media.Playback {
  public enum AutoLoadedDisplayPropertyKind
  public sealed class CurrentMediaPlaybackItemChangedEventArgs {
    MediaPlaybackItemChangedReason Reason { get; }
  }
  public sealed class MediaPlaybackItem : IMediaPlaybackSource {
    AutoLoadedDisplayPropertyKind AutoLoadedDisplayProperties { get; set; }
    bool IsDisabledInPlaybackList { get; set; }
    double TotalDownloadProgress { get; }
  }
 public enum MediaPlaybackItemChangedReason
  public sealed class MediaPlaybackList : IMediaPlaybackSource {
    IReference<uint> MaxPlayedItemsToKeepOpen { get; set; }
  }
  public sealed class MediaPlaybackSession {
    bool IsMirroring { get; set; }
    MediaPlaybackSphericalVideoProjection SphericalVideoProjection { get; }
    event TypedEventHandler<MediaPlaybackSession, object> BufferedRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> PlayedRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> SeekableRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> SupportedPlaybackRatesChanged;
    IVectorView<MediaTimeRange> GetBufferedRanges();
    IVectorView<MediaTimeRange> GetPlayedRanges();
    IVectorView<MediaTimeRange> GetSeekableRanges();
    bool IsSupportedPlaybackRateRange(double rate1, double rate2);
  }
  public sealed class MediaPlaybackSphericalVideoProjection
  public sealed class MediaPlayer : IClosable {
    bool IsVideoFrameServerEnabled { get; set; }
    event TypedEventHandler<MediaPlayer, object> VideoFrameAvailable;
    void CopyFrameToStereoscopicVideoSurfaces(IDirect3DSurface destinationLeftEye, IDirect3DSurface destinationRightEye);
    void CopyFrameToVideoSurface(IDirect3DSurface destination);
    void CopyFrameToVideoSurface(IDirect3DSurface destination, Rect targetRectangle);
  }
  public enum SphericalVideoProjectionMode
}
namespace Windows.Media.Protection.PlayReady {
  public interface IPlayReadyLicenseSession2 : IPlayReadyLicenseSession
  public sealed class PlayReadyLicense : IPlayReadyLicense {
    bool ExpiresInRealTime { get; }
    bool InMemoryOnly { get; }
    Guid SecureStopId { get; }
    uint SecurityLevel { get; }
  }
  public sealed class PlayReadyLicenseAcquisitionServiceRequest : IMediaProtectionServiceRequest, IPlayReadyLicenseAcquisitionServiceRequest, IPlayReadyServiceRequest {
    PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
  }
  public sealed class PlayReadyLicenseSession : IPlayReadyLicenseSession, IPlayReadyLicenseSession2 {
    PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
  }
}
namespace Windows.Media.SpeechSynthesis {
  public sealed class SpeechSynthesisStream : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType, ITimedMetadataTrackProvider {
    IVectorView<TimedMetadataTrack> TimedMetadataTracks { get; }
  }
  public sealed class SpeechSynthesizer : IClosable {
    SpeechSynthesizerOptions Options { get; }
  }
  public sealed class SpeechSynthesizerOptions
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSource : IClosable, IMediaSource {
    IReference<TimeSpan> DesiredSeekableWindowSize { get; set; }
    AdaptiveMediaSourceDiagnostics Diagnostics { get; }
    IReference<TimeSpan> MaxSeekableWindowSize { get; }
    IReference<TimeSpan> MinLiveOffset { get; }
    void Close();
    AdaptiveMediaSourceCorrelatedTimes GetCorrelatedTimes();
  }
  public sealed class AdaptiveMediaSourceCorrelatedTimes
  public sealed class AdaptiveMediaSourceCreationResult {
    HResult ExtendedError { get; }
  }
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs
  public sealed class AdaptiveMediaSourceDiagnostics
  public enum AdaptiveMediaSourceDiagnosticType
  public sealed class AdaptiveMediaSourceDownloadBitrateChangedEventArgs {
    AdaptiveMediaSourceDownloadBitrateChangedReason Reason { get; }
  }
  public enum AdaptiveMediaSourceDownloadBitrateChangedReason
  public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
    IReference<TimeSpan> Position { get; }
    int RequestId { get; }
    AdaptiveMediaSourceDownloadStatistics Statistics { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
    HResult ExtendedError { get; }
    IReference<TimeSpan> Position { get; }
    int RequestId { get; }
    AdaptiveMediaSourceDownloadStatistics Statistics { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
    IReference<TimeSpan> Position { get; }
    int RequestId { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadStatistics
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAccount {
    Uri AccountExperienceUrl { get; }
  }
  public sealed class MobileBroadbandDeviceInformation {
    string SimGid1 { get; }
    string SimPnn { get; }
    string SimSpn { get; }
  }
}
namespace Windows.Networking.PushNotifications {
  public static class PushNotificationChannelManager {
    public static PushNotificationChannelManagerForUser GetDefault();
  }
  public sealed class PushNotificationChannelManagerForUser {
    IAsyncOperation<PushNotificationChannel> CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(IBuffer appServerKey, string channelId);
    IAsyncOperation<PushNotificationChannel> CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(IBuffer appServerKey, string channelId, string appId);
  }
  public sealed class RawNotification {
    string ChannelId { get; }
    IMapView<string, string> Headers { get; }
  }
}
namespace Windows.Perception.Spatial {
  public sealed class SpatialEntity
  public sealed class SpatialEntityAddedEventArgs
  public sealed class SpatialEntityRemovedEventArgs
  public sealed class SpatialEntityStore
  public sealed class SpatialEntityUpdatedEventArgs
  public sealed class SpatialEntityWatcher
  public enum SpatialEntityWatcherStatus
  public enum SpatialLookDirectionRange
  public enum SpatialMovementRange
  public sealed class SpatialStageFrameOfReference
}
namespace Windows.Perception.Spatial.Surfaces {
  public sealed class SpatialSurfaceObserver {
    public static bool IsSupported();
  }
}
namespace Windows.Security.Authentication.Identity.Provider {
  public enum SecondaryAuthenticationFactorAuthenticationStage {
    CheckingDevicePresence = 8,
  }
  public enum SecondaryAuthenticationFactorDeviceCapabilities : uint {
    CloseRangeDataTransmission = (uint)64,
  }
  public enum SecondaryAuthenticationFactorDevicePresence
  public enum SecondaryAuthenticationFactorDevicePresenceMonitoringMode
  public enum SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus
  public sealed class SecondaryAuthenticationFactorInfo {
    bool IsAuthenticationSupported { get; }
    SecondaryAuthenticationFactorDevicePresenceMonitoringMode PresenceMonitoringMode { get; }
    IAsyncAction UpdateDevicePresenceAsync(SecondaryAuthenticationFactorDevicePresence presenceState);
  }
  public sealed class SecondaryAuthenticationFactorRegistration {
    public static bool IsDevicePresenceMonitoringSupported();
    public static IAsyncOperation<SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus> RegisterDevicePresenceMonitoringAsync(string deviceId, string deviceInstancePath, SecondaryAuthenticationFactorDevicePresenceMonitoringMode monitoringMode);
    public static IAsyncOperation<SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus> RegisterDevicePresenceMonitoringAsync(string deviceId, string deviceInstancePath, SecondaryAuthenticationFactorDevicePresenceMonitoringMode monitoringMode, string deviceFriendlyName, string deviceModelNumber, IBuffer deviceConfigurationData);
    public static IAsyncAction UnregisterDevicePresenceMonitoringAsync(string deviceId);
  }
}
namespace Windows.Security.Authentication.OnlineId {
  public static class OnlineIdSystemAuthenticator
  public sealed class OnlineIdSystemAuthenticatorForUser
  public sealed class OnlineIdSystemIdentity
  public sealed class OnlineIdSystemTicketResult
  public enum OnlineIdSystemTicketStatus
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class WebTokenRequest {
    string CorrelationId { get; set; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public static class WebAccountManager {
    public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props);
    public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props, WebAccountScope scope);
    public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props, WebAccountScope scope, string perUserWebAccountId);
    public static IAsyncOperation<IVectorView<WebAccount>> FindAllProviderWebAccountsForUserAsync(User user);
  }
  public sealed class WebAccountProviderTriggerDetails : IWebAccountProviderTokenObjects {
    User User { get; }
  }
}
namespace Windows.Security.Cryptography.Certificates {
  public sealed class CertificateExtension
  public sealed class CertificateRequestProperties {
    IVector<CertificateExtension> Extensions { get; }
    SubjectAlternativeNameInfo SubjectAlternativeName { get; }
    IVector<string> SuppressedDefaults { get; }
  }
  public sealed class SubjectAlternativeNameInfo {
    IVector<string> DistinguishedNames { get; }
    IVector<string> DnsNames { get; }
    IVector<string> EmailNames { get; }
    CertificateExtension Extension { get; }
    IVector<string> IPAddresses { get; }
    IVector<string> PrincipalNames { get; }
    IVector<string> Urls { get; }
  }
}
namespace Windows.Services.Cortana {
  public enum CortanaPermission
  public enum CortanaPermissionsChangeResult
  public sealed class CortanaPermissionsManager
}
namespace Windows.Services.Maps {
  public sealed class EnhancedWaypoint
  public sealed class ManeuverWarning
  public enum ManeuverWarningKind
  public enum ManeuverWarningSeverity
  public sealed class MapRoute {
    TimeSpan DurationWithoutTraffic { get; }
    TrafficCongestion TrafficCongestion { get; }
  }
  public static class MapRouteFinder {
    public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints);
    public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints, MapRouteDrivingOptions options);
  }
  public sealed class MapRouteLeg {
    TimeSpan DurationWithoutTraffic { get; }
    TrafficCongestion TrafficCongestion { get; }
  }
  public sealed class MapRouteManeuver {
    IVectorView<ManeuverWarning> Warnings { get; }
  }
  public static class MapService {
    public static MapServiceDataUsagePreference DataUsagePreference { get; set; }
  }
  public enum MapServiceDataUsagePreference
  public enum TrafficCongestion
  public enum WaypointKind
}
namespace Windows.Services.Maps.OfflineMaps {
  public sealed class OfflineMapPackage
  public sealed class OfflineMapPackageQueryResult
  public enum OfflineMapPackageQueryStatus
  public sealed class OfflineMapPackageStartDownloadResult
  public enum OfflineMapPackageStartDownloadStatus
  public enum OfflineMapPackageStatus
}
namespace Windows.Storage {
  public enum KnownFolderId {
    AllAppMods = 14,
    CurrentAppMods = 15,
  }
  public sealed class StorageLibrary {
    IAsyncOperation<bool> AreFolderSuggestionsAvailableAsync();
  }
  public enum StorageOpenOptions : uint {
    AllowReadersAndWriters = (uint)2,
  }
}
namespace Windows.System {
  public sealed class AppDiagnosticInfo
  public sealed class LauncherOptions : ILauncherViewOptions {
    bool LimitPickerToCurrentAppAndAppUriHandlers { get; set; }
  }
}
namespace Windows.System.Diagnostics {
  public sealed class SystemCpuUsage
  public sealed class SystemCpuUsageReport
  public sealed class SystemDiagnosticInfo
 public sealed class SystemMemoryUsage
  public sealed class SystemMemoryUsageReport
}
namespace Windows.System.Diagnostics.DevicePortal {
  public sealed class DevicePortalConnection
  public sealed class DevicePortalConnectionClosedEventArgs
  public enum DevicePortalConnectionClosedReason
  public sealed class DevicePortalConnectionRequestReceivedEventArgs
}
namespace Windows.System.Diagnostics.TraceReporting {
  public static class PlatformDiagnosticActions
  public enum PlatformDiagnosticActionState
  public enum PlatformDiagnosticEscalationType
  public enum PlatformDiagnosticEventBufferLatencies : uint
  public sealed class PlatformDiagnosticTraceInfo
  public enum PlatformDiagnosticTracePriority
  public sealed class PlatformDiagnosticTraceRuntimeInfo
  public enum PlatformDiagnosticTraceSlotState
  public enum PlatformDiagnosticTraceSlotType
}
namespace Windows.System.Profile {
  public static class EducationSettings
}
namespace Windows.System.RemoteSystems {
  public static class KnownRemoteSystemCapabilities
  public sealed class RemoteSystem {
    bool IsAvailableBySpatialProximity { get; }
    IAsyncOperation<bool> GetCapabilitySupportedAsync(string capabilityName);
    public static bool IsAuthorizationKindEnabled(RemoteSystemAuthorizationKind kind);
  }
  public enum RemoteSystemAuthorizationKind
  public sealed class RemoteSystemAuthorizationKindFilter : IRemoteSystemFilter
  public enum RemoteSystemDiscoveryType {
    SpatiallyProximal = 3,
  }
  public sealed class RemoteSystemSession : IClosable
  public sealed class RemoteSystemSessionAddedEventArgs
  public sealed class RemoteSystemSessionController
  public sealed class RemoteSystemSessionCreationResult
  public enum RemoteSystemSessionCreationStatus
  public sealed class RemoteSystemSessionDisconnectedEventArgs
  public enum RemoteSystemSessionDisconnectedReason
  public sealed class RemoteSystemSessionInfo
  public sealed class RemoteSystemSessionInvitation
  public sealed class RemoteSystemSessionInvitationListener
  public sealed class RemoteSystemSessionInvitationReceivedEventArgs
  public sealed class RemoteSystemSessionJoinRequest
  public sealed class RemoteSystemSessionJoinRequestedEventArgs
  public sealed class RemoteSystemSessionJoinResult
  public enum RemoteSystemSessionJoinStatus
  public sealed class RemoteSystemSessionMessageChannel
  public enum RemoteSystemSessionMessageChannelReliability
  public sealed class RemoteSystemSessionOptions
  public sealed class RemoteSystemSessionParticipant
  public sealed class RemoteSystemSessionParticipantAddedEventArgs
  public sealed class RemoteSystemSessionParticipantRemovedEventArgs
  public sealed class RemoteSystemSessionParticipantWatcher
  public enum RemoteSystemSessionParticipantWatcherStatus
  public sealed class RemoteSystemSessionRemovedEventArgs
  public sealed class RemoteSystemSessionUpdatedEventArgs
  public sealed class RemoteSystemSessionValueSetReceivedEventArgs
  public sealed class RemoteSystemSessionWatcher
  public enum RemoteSystemSessionWatcherStatus
}
namespace Windows.UI {
  public sealed class ColorHelper {
    public static string ToDisplayName(Color color);
  }
}
namespace Windows.UI.Composition {
  public enum AnimationDelayBehavior
  public sealed class CompositionCapabilities
  public class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
    SizeInt32 SizeInt32 { get; }
    void Resize(SizeInt32 sizePixels);
    void Scroll(PointInt32 offset);
    void Scroll(PointInt32 offset, RectInt32 scrollRect);
    void ScrollWithClip(PointInt32 offset, RectInt32 clipRect);
    void ScrollWithClip(PointInt32 offset, RectInt32 clipRect, RectInt32 scrollRect);
  }
  public sealed class CompositionGraphicsDevice : CompositionObject {
    CompositionDrawingSurface CreateDrawingSurface2(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
    CompositionVirtualDrawingSurface CreateVirtualDrawingSurface(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
  }
  public class CompositionVirtualDrawingSurface : CompositionDrawingSurface
  public sealed class Compositor : IClosable {
    CompositionBackdropBrush CreateHostBackdropBrush();
  }
  public interface ICompositionColorSpaceTarget
  public class KeyFrameAnimation : CompositionAnimation {
    AnimationDelayBehavior DelayBehavior { get; set; }
  }
  public class Visual : CompositionObject {
    Visual ParentForTransform { get; set; }
    Vector3 RelativeOffsetAdjustment { get; set; }
    Vector2 RelativeSizeAdjustment { get; set; }
  }
  public sealed class VisualCapturePartner : CompositionObject, IAsyncInfo, IAsyncOperation<ICompositionSurface>
}
namespace Windows.UI.Composition.Interactions {
  public sealed class CompositionConditionalValue : CompositionObject
  public sealed class InteractionTracker : CompositionObject {
    void ConfigureCenterPointXInertiaModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureCenterPointYInertiaModifiers(IIterable<CompositionConditionalValue> conditionalValues);
  }
  public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
    Vector3 DeltaPosition { get; }
    float DeltaScale { get; }
    Vector3 Position { get; }
    Vector3 PositionVelocity { get; }
    float Scale { get; }
    float ScaleVelocity { get; }
    void ConfigureCenterPointXModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureCenterPointYModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureDeltaPositionXModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureDeltaPositionYModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureDeltaScaleModifiers(IIterable<CompositionConditionalValue> conditionalValues);
  }
}
namespace Windows.UI.Core {
  public sealed class ComponentDisplayInformation
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    event TypedEventHandler<CoreWindow, object> ResizeCompleted;
    event TypedEventHandler<CoreWindow, object> ResizeStarted;
  }
  public sealed class SystemNavigationCloseRequestedEventArgs
  public sealed class SystemNavigationManager {
    event TypedEventHandler<SystemNavigationManager, SystemNavigationCloseRequestedEventArgs> CloseRequested;
  }
}
namespace Windows.UI.Input {
  public sealed class RadialController {
    event TypedEventHandler<RadialController, RadialControllerButtonHoldingEventArgs> ButtonHolding;
    event TypedEventHandler<RadialController, RadialControllerButtonPressedEventArgs> ButtonPressed;
    event TypedEventHandler<RadialController, RadialControllerButtonReleasedEventArgs> ButtonReleased;
  }
  public sealed class RadialControllerButtonClickedEventArgs {
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerButtonHoldingEventArgs
  public sealed class RadialControllerButtonPressedEventArgs
  public sealed class RadialControllerButtonReleasedEventArgs
  public sealed class RadialControllerConfiguration {
    RadialController ActiveControllerWhenMenuIsSuppressed { get; set; }
    bool IsMenuSuppressed { get; set; }
  }
  public sealed class RadialControllerControlAcquiredEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerMenuItem {
    public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily);
    public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily, Uri fontUri);
  }
  public sealed class RadialControllerRotationChangedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerScreenContactContinuedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerScreenContactEndedEventArgs
  public sealed class RadialControllerScreenContactStartedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
}
namespace Windows.UI.Input.Core {
  public sealed class RadialControllerIndependentInputSource
}
namespace Windows.UI.Input.Inking {
  public sealed class InkDrawingAttributes {
    bool IgnoreTilt { get; set; }
  }
  public enum InkHighContrastAdjustment
  public enum InkPersistenceFormat
  public sealed class InkPoint {
    public InkPoint(Point position, float pressure, float tiltX, float tiltY, ulong timestamp);
    float TiltX { get; }
    float TiltY { get; }
    ulong Timestamp { get; }
  }
  public sealed class InkPresenter {
    InkHighContrastAdjustment HighContrastAdjustment { get; set; }
  }
  public sealed class InkPresenterProtractor : IInkPresenterStencil
  public sealed class InkPresenterRuler : IInkPresenterStencil {
    bool AreTickMarksVisible { get; set; }
    bool IsCompassVisible { get; set; }
  }
  public enum InkPresenterStencilKind {
    Protractor = 2,
  }
  public sealed class InkStroke {
    uint Id { get; }
    IReference<TimeSpan> StrokeDuration { get; set; }
    IReference<DateTime> StrokeStartedTime { get; set; }
  }
  public sealed class InkStrokeBuilder {
    InkStroke CreateStrokeFromInkPoints(IIterable<InkPoint> inkPoints, Matrix3x2 transform, IReference<DateTime> strokeStartedTime, IReference<TimeSpan> strokeDuration);
  }
  public sealed class InkStrokeContainer : IInkStrokeContainer {
    InkStroke GetStrokeById(uint id);
    IAsyncOperationWithProgress<uint, uint> SaveAsync(IOutputStream outputStream, InkPersistenceFormat inkPersistenceFormat);
  }
}
namespace Windows.UI.Input.Inking.Analysis {
  public interface IInkAnalysisNode
  public interface IInkAnalyzerFactory
  public enum InkAnalysisDrawingKind
  public sealed class InkAnalysisInkBullet : IInkAnalysisNode
  public sealed class InkAnalysisInkDrawing : IInkAnalysisNode
  public sealed class InkAnalysisInkWord : IInkAnalysisNode
  public sealed class InkAnalysisLine : IInkAnalysisNode
  public sealed class InkAnalysisListItem : IInkAnalysisNode
  public sealed class InkAnalysisNode : IInkAnalysisNode
  public enum InkAnalysisNodeKind
  public sealed class InkAnalysisParagraph : IInkAnalysisNode
  public sealed class InkAnalysisResult
  public sealed class InkAnalysisRoot : IInkAnalysisNode
  public enum InkAnalysisStatus
  public enum InkAnalysisStrokeKind
  public sealed class InkAnalysisWritingRegion : IInkAnalysisNode
  public sealed class InkAnalyzer
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController
  public sealed class SpatialInteractionControllerProperties
  public sealed class SpatialInteractionDetectedEventArgs {
    SpatialInteractionSource InteractionSource { get; }
  }
  public enum SpatialInteractionPressKind
  public sealed class SpatialInteractionSource {
    SpatialInteractionController Controller { get; }
    bool IsGraspSupported { get; }
    bool IsMenuSupported { get; }
    bool IsPointingSupported { get; }
    SpatialInteractionSourceState TryGetStateAtTimestamp(PerceptionTimestamp timestamp);
  }
  public sealed class SpatialInteractionSourceEventArgs {
    SpatialInteractionPressKind PressKind { get; }
  }
  public sealed class SpatialInteractionSourceState {
    SpatialInteractionControllerProperties ControllerProperties { get; }
    bool IsGrasped { get; }
    bool IsMenuPressed { get; }
    bool IsSelectPressed { get; }
    double SelectPressedValue { get; }
  }
  public sealed class SpatialPointerInteractionSourcePose
  public sealed class SpatialPointerPose {
    SpatialPointerInteractionSourcePose TryGetInteractionSourcePose(SpatialInteractionSource source);
  }
}
namespace Windows.UI.Notifications {
  public sealed class NotificationData
  public enum NotificationUpdateResult
  public sealed class ToastCollection
  public sealed class ToastCollectionManager
  public sealed class ToastNotification {
    NotificationData Data { get; set; }
  }
  public sealed class ToastNotificationHistoryChangedTriggerDetail {
    string CollectionId { get; }
  }
  public static class ToastNotificationManager {
    public static ToastNotificationManagerForUser GetDefault();
  }
  public sealed class ToastNotificationManagerForUser {
    IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionIdAsync(string collectionId);
    ToastCollectionManager GetToastCollectionManager();
    ToastCollectionManager GetToastCollectionManager(string appId);
    IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionIdAsync(string collectionId);
  }
  public sealed class ToastNotifier {
    NotificationUpdateResult Update(NotificationData data, string tag);
    NotificationUpdateResult Update(NotificationData data, string tag, string group);
  }
}
namespace Windows.UI.StartScreen {
  public sealed class StartScreenManager
}
namespace Windows.UI.Text {
  public sealed class RichEditTextDocument : ITextDocument
  public enum TextDecorations : uint
  public enum TextGetOptions : uint {
    UseLf = (uint)16777216,
  }
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationView {
    ApplicationViewMode ViewMode { get; }
    bool IsViewModeSupported(ApplicationViewMode viewMode);
    IAsyncOperation<bool> TryConsolidateAsync();
    IAsyncOperation<bool> TryEnterViewModeAsync(ApplicationViewMode viewMode);
    IAsyncOperation<bool> TryEnterViewModeAsync(ApplicationViewMode viewMode, ViewModePreferences viewModePreferences);
  }
  public sealed class ApplicationViewConsolidatedEventArgs {
    bool IsAppInitiated { get; }
  }
  public enum ApplicationViewMode
  public static class ApplicationViewSwitcher {
    public static IAsyncOperation<bool> TryShowAsViewModeAsync(int viewId, ApplicationViewMode viewMode);
    public static IAsyncOperation<bool> TryShowAsViewModeAsync(int viewId, ApplicationViewMode viewMode, ViewModePreferences viewModePreferences);
  }
  public sealed class UISettings {
    bool AdvancedEffectsEnabled { get; }
   event TypedEventHandler<UISettings, object> AdvancedEffectsEnabledChanged;
  }
  public sealed class ViewModePreferences
  public enum ViewSizePreference {
    Custom = 6,
  }
}
namespace Windows.UI.WebUI {
  public sealed class WebUIContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
  public sealed class WebUILockScreenComponentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral
}
namespace Windows.UI.Xaml {
  public class Application {
    ApplicationHighContrastAdjustment HighContrastAdjustment { get; set; }
  }
  public enum ApplicationHighContrastAdjustment : uint
  public sealed class BringIntoViewOptions
  public enum ElementHighContrastAdjustment : uint
  public class FrameworkElement : UIElement {
    public static void DeferTree(DependencyObject element);
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent GettingFocusEvent { get; }
    ElementHighContrastAdjustment HighContrastAdjustment { get; set; }
    public static DependencyProperty HighContrastAdjustmentProperty { get; }
    double KeyTipHorizontalOffset { get; set; }
    public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
    KeyTipPlacementMode KeyTipPlacementMode { get; set; }
    public static DependencyProperty KeyTipPlacementModeProperty { get; }
    double KeyTipVerticalOffset { get; set; }
    public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
    IVector<XamlLight> Lights { get; }
    public static DependencyProperty LightsProperty { get; }
    public static RoutedEvent LosingFocusEvent { get; }
    public static RoutedEvent NoFocusCandidateFoundEvent { get; }
    KeyboardNavigationMode TabFocusNavigation { get; set; }
    public static DependencyProperty TabFocusNavigationProperty { get; }
    XYFocusNavigationStrategy XYFocusDownNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusDownNavigationStrategyProperty { get; }
    XYFocusKeyboardNavigationMode XYFocusKeyboardNavigation { get; set; }
    public static DependencyProperty XYFocusKeyboardNavigationProperty { get; }
    XYFocusNavigationStrategy XYFocusLeftNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusLeftNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusRightNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusRightNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusUpNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusUpNavigationStrategyProperty { get; }
    event TypedEventHandler<UIElement, GettingFocusEventArgs> GettingFocus;
    event TypedEventHandler<UIElement, LosingFocusEventArgs> LosingFocus;
    event TypedEventHandler<UIElement, NoFocusCandidateFoundEventArgs> NoFocusCandidateFound;
    void StartBringIntoView();
    void StartBringIntoView(BringIntoViewOptions options);
  }
  public sealed class Window {
    Compositor Compositor { get; }
  }
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty CultureProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty CultureProperty { get; }
    public static int GetCulture(DependencyObject element);
    public static void SetCulture(DependencyObject element, int value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public class AutomationPeer : DependencyObject {
    int GetCulture();
    virtual int GetCultureCore();
  }
  public sealed class MapControlAutomationPeer : FrameworkElementAutomationPeer, IScrollProvider, ITransformProvider, ITransformProvider2 {
    bool CanMove { get; }
    bool CanResize { get; }
    bool CanRotate { get; }
    bool CanZoom { get; }
    double MaxZoom { get; }
    double MinZoom { get; }
    double ZoomLevel { get; }
    void Move(double x, double y);
    void Resize(double width, double height);
    void Rotate(double degrees);
    void Zoom(double zoom);
    void ZoomByUnit(ZoomUnit zoomUnit);
  }
}
namespace Windows.UI.Xaml.Controls {
  public class BitmapIcon : IconElement {
    bool ShowAsMonochrome { get; set; }
    public static DependencyProperty ShowAsMonochromeProperty { get; }
  }
  public class ComboBox : Selector {
    ComboBoxSelectionChangedTrigger SelectionChangedTrigger { get; set; }
    public static DependencyProperty SelectionChangedTriggerProperty { get; }
  }
  public enum ComboBoxSelectionChangedTrigger
  public class ContentDialog : ContentControl {
    ICommand CloseButtonCommand { get; set; }
    object CloseButtonCommandParameter { get; set; }
    public static DependencyProperty CloseButtonCommandParameterProperty { get; }
    public static DependencyProperty CloseButtonCommandProperty { get; }
    Style CloseButtonStyle { get; set; }
    public static DependencyProperty CloseButtonStyleProperty { get; }
    string CloseButtonText { get; set; }
    public static DependencyProperty CloseButtonTextProperty { get; }
    ContentDialogButton DefaultButton { get; set; }
    public static DependencyProperty DefaultButtonProperty { get; }
    Style PrimaryButtonStyle { get; set; }
    public static DependencyProperty PrimaryButtonStyleProperty { get; }
    Style SecondaryButtonStyle { get; set; }
    public static DependencyProperty SecondaryButtonStyleProperty { get; }
    event TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> CloseButtonClick;
  }
  public enum ContentDialogButton
  public class Control : FrameworkElement {
    Uri DefaultStyleResourceUri { get; set; }
    public static DependencyProperty DefaultStyleResourceUriProperty { get; }
    public static DependencyProperty IsTemplateKeyTipTargetProperty { get; }
    public static bool GetIsTemplateKeyTipTarget(DependencyObject element);
    public static void SetIsTemplateKeyTipTarget(DependencyObject element, bool value);
  }
  public sealed class FocusEngagedEventArgs : RoutedEventArgs {
    bool Handled { get; set; }
  }
  public class Frame : ContentControl, INavigate {
    void SetNavigationState(string navigationState, bool suppressNavigate);
  }
  public class InkToolbar : Control {
    InkToolbarButtonFlyoutPlacement ButtonFlyoutPlacement { get; set; }
    public static DependencyProperty ButtonFlyoutPlacementProperty { get; }
    bool IsStencilButtonChecked { get; set; }
    public static DependencyProperty IsStencilButtonCheckedProperty { get; }
    Orientation Orientation { get; set; }
    public static DependencyProperty OrientationProperty { get; }
    event TypedEventHandler<InkToolbar, InkToolbarIsStencilButtonCheckedChangedEventArgs> IsStencilButtonCheckedChanged;
    InkToolbarMenuButton GetMenuButton(InkToolbarMenuKind menu);
  }
  public enum InkToolbarButtonFlyoutPlacement
  public class InkToolbarEraserButton : InkToolbarToolButton {
    bool IsClearAllVisible { get; set; }
    public static DependencyProperty IsClearAllVisibleProperty { get; }
  }
  public class InkToolbarFlyoutItem : ButtonBase
  public enum InkToolbarFlyoutItemKind
  public sealed class InkToolbarIsStencilButtonCheckedChangedEventArgs
  public class InkToolbarMenuButton : ToggleButton
  public enum InkToolbarMenuKind
  public class InkToolbarStencilButton : InkToolbarMenuButton
  public enum InkToolbarStencilKind
  public class ListViewBase : Selector, ISemanticZoomInformation {
    ConnectedAnimation PrepareConnectedAnimation(string key, object item, string elementName);
    IAsyncOperation<bool> TryStartConnectedAnimationAsync(ConnectedAnimation animation, object item, string elementName);
  }
  public class MenuFlyoutItem : MenuFlyoutItemBase {
    IconElement Icon { get; set; }
    public static DependencyProperty IconProperty { get; }
  }
  public sealed class MenuFlyoutSubItem : MenuFlyoutItemBase {
    IconElement Icon { get; set; }
    public static DependencyProperty IconProperty { get; }
  }
  public class RichEditBox : Control {
    int MaxLength { get; set; }
    public static DependencyProperty MaxLengthProperty { get; }
    SolidColorBrush SelectionHighlightColorWhenNotFocused { get; set; }
    public static DependencyProperty SelectionHighlightColorWhenNotFocusedProperty { get; }
  }
  public sealed class RichEditBoxTextChangingEventArgs {
    bool IsContentChanging { get; }
  }
  public sealed class RichTextBlock : FrameworkElement {
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
  }
  public sealed class TextBlock : FrameworkElement {
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
  }
  public class TextBox : Control {
    SolidColorBrush SelectionHighlightColorWhenNotFocused { get; set; }
    public static DependencyProperty SelectionHighlightColorWhenNotFocusedProperty { get; }
  }
  public sealed class TextBoxTextChangingEventArgs {
    bool IsContentChanging { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapBillboard : MapElement
  public sealed class MapContextRequestedEventArgs
  public sealed class MapControl : Control {
    MapProjection MapProjection { get; set; }
    public static DependencyProperty MapProjectionProperty { get; }
    MapStyleSheet StyleSheet { get; set; }
    public static DependencyProperty StyleSheetProperty { get; }
    Thickness ViewPadding { get; set; }
    public static DependencyProperty ViewPaddingProperty { get; }
    event TypedEventHandler<MapControl, MapContextRequestedEventArgs> MapContextRequested;
    IVectorView<MapElement> FindMapElementsAtOffset(Point offset, double radius);
    void GetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
    void StartContinuousPan(double horizontalPixelsPerSecond, double verticalPixelsPerSecond);
    void StopContinuousPan();
    IAsyncOperation<bool> TryPanAsync(double horizontalPixels, double verticalPixels);
    IAsyncOperation<bool> TryPanToAsync(Geopoint location);
  }
  public enum MapProjection
  public enum MapStyle {
    Custom = 7,
  }
  public sealed class MapStyleSheet : DependencyObject
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class FlyoutBase : DependencyObject {
    DependencyObject OverlayInputPassThroughElement { get; set; }
    public static DependencyProperty OverlayInputPassThroughElementProperty { get; }
  }
}
namespace Windows.UI.Xaml.Documents {
  public sealed class Hyperlink : Span {
    FocusState FocusState { get; }
    public static DependencyProperty FocusStateProperty { get; }
    XYFocusNavigationStrategy XYFocusDownNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusDownNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusLeftNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusLeftNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusRightNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusRightNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusUpNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusUpNavigationStrategyProperty { get; }
    event RoutedEventHandler GotFocus;
    event RoutedEventHandler LostFocus;
    bool Focus(FocusState value);
  }
  public class TextElement : DependencyObject {
    DependencyObject AccessKeyScopeOwner { get; set; }
    public static DependencyProperty AccessKeyScopeOwnerProperty { get; }
    bool IsAccessKeyScope { get; set; }
    public static DependencyProperty IsAccessKeyScopeProperty { get; }
    double KeyTipHorizontalOffset { get; set; }
    public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
    KeyTipPlacementMode KeyTipPlacementMode { get; set; }
    public static DependencyProperty KeyTipPlacementModeProperty { get; }
    double KeyTipVerticalOffset { get; set; }
    public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
    event TypedEventHandler<TextElement, AccessKeyDisplayDismissedEventArgs> AccessKeyDisplayDismissed;
    event TypedEventHandler<TextElement, AccessKeyDisplayRequestedEventArgs> AccessKeyDisplayRequested;
    event TypedEventHandler<TextElement, AccessKeyInvokedEventArgs> AccessKeyInvoked;
  }
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class ElementCompositionPreview {
    public static CompositionPropertySet GetPointerPositionPropertySet(UIElement targetElement);
    public static void SetImplicitHideAnimation(UIElement element, ICompositionAnimationBase animation);
    public static void SetImplicitShowAnimation(UIElement element, ICompositionAnimationBase animation);
    public static void SetIsTranslationEnabled(UIElement element, bool value);
  }
}
namespace Windows.UI.Xaml.Input {
  public sealed class AccessKeyManager {
    public static bool AreKeyTipsEnabled { get; set; }
  }
  public sealed class FindNextElementOptions
  public enum FocusInputDeviceKind
  public sealed class FocusManager {
    public static DependencyObject FindFirstFocusableElement(DependencyObject searchScope);
    public static DependencyObject FindLastFocusableElement(DependencyObject searchScope);
    public static DependencyObject FindNextElement(FocusNavigationDirection focusNavigationDirection);
    public static DependencyObject FindNextElement(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
    public static bool TryMoveFocus(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
  }
  public sealed class GettingFocusEventArgs : RoutedEventArgs
  public enum KeyTipPlacementMode
  public sealed class LosingFocusEventArgs : RoutedEventArgs
  public sealed class NoFocusCandidateFoundEventArgs : RoutedEventArgs
  public enum XYFocusKeyboardNavigationMode
  public enum XYFocusNavigationStrategy
  public enum XYFocusNavigationStrategyOverride
}
namespace Windows.UI.Xaml.Markup {
  public sealed class XamlMarkupHelper
}
namespace Windows.UI.Xaml.Media {
  public sealed class LoadedImageSourceLoadCompletedEventArgs
  public enum LoadedImageSourceLoadStatus
  public sealed class LoadedImageSurface : IClosable, ICompositionSurface
  public class XamlCompositionBrushBase : Brush
  public class XamlLight : DependencyObject
}
namespace Windows.UI.Xaml.Media.Animation {
  public sealed class ConnectedAnimation {
    bool IsScaleAnimationEnabled { get; set; }
    void SetAnimationComponent(ConnectedAnimationComponent component, ICompositionAnimationBase animation);
    bool TryStart(UIElement destination, IIterable<UIElement> coordinatedElements);
  }
  public enum ConnectedAnimationComponent
}
namespace Windows.UI.Xaml.Media.Imaging {
  public class SvgImageSource : ImageSource
  public sealed class SvgImageSourceFailedEventArgs
  public enum SvgImageSourceLoadStatus
  public sealed class SvgImageSourceOpenedEventArgs
}
namespace Windows.Media.Capture {
  public sealed class AppCaptureDurationGeneratedEventArgs
  public sealed class AppCaptureFileGeneratedEventArgs
  public enum AppCaptureMicrophoneCaptureState
  public sealed class AppCaptureMicrophoneCaptureStateChangedEventArgs
  public enum AppCaptureRecordingState
  public sealed class AppCaptureRecordingStateChangedEventArgs
  public sealed class AppCaptureRecordOperation
  public sealed class AppCaptureServices
  public sealed class AppCaptureSettings {
    bool IsCursorImageCaptureEnabled { get; set; }
    bool IsEchoCancellationEnabled { get; set; }
  }
  public sealed class AppCaptureState
}
namespace Windows.Security.EnterpriseData {
  public static class FileProtectionManager {
    public static IAsyncOperation<FileProtectionInfo> UnprotectAsync(IStorageItem target);
    public static IAsyncOperation<FileProtectionInfo> UnprotectAsync(IStorageItem target, FileUnprotectOptions options);
  }
  public sealed class FileUnprotectOptions
  public sealed class ProtectionPolicyManager {
    public static string PrimaryManagedIdentity { get; }
    public static string GetPrimaryManagedIdentityForIdentity(string identity);
    public static IAsyncOperation<bool> IsFileProtectionRequiredAsync(IStorageItem target, string identity);
    public static IAsyncOperation<bool> IsFileProtectionRequiredForNewFileAsync(IStorageFolder parentFolder, string identity, string desiredName);
    public static bool IsRoamableProtectionEnabled(string identity);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessAsync(string sourceIdentity, string targetIdentity, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessForAppAsync(string sourceIdentity, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForAppAsync(IIterable<IStorageItem> sourceItemList, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForAppAsync(IIterable<IStorageItem> sourceItemList, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForProcessAsync(IIterable<IStorageItem> sourceItemList, uint processId, ProtectionPolicyAuditInfo auditInfo);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForProcessAsync(IIterable<IStorageItem> sourceItemList, uint processId, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
  }
}
namespace Windows.Services.Store {
  public sealed class StoreContext {
    IAsyncOperation<StoreProductResult> FindStoreProductForPackageAsync(IIterable<string> productKinds, Package package);
  }
  public sealed class StoreSendRequestResult {
    HttpStatusCode HttpStatusCode { get; }
  }
}
namespace Windows.System.Profile {
  public static class SharedModeSettings {
    public static bool ShouldAvoidLocalStorage { get; }
  }
}
namespace Windows.Services.Cortana {
  public sealed class CortanaSettings
}
namespace Windows.System {
  public enum PowerState
  public static class ShutdownManager {
    public static void EnterPowerState(PowerState powerState);
    public static void EnterPowerState(PowerState powerState, TimeSpan wakeUpAfter);
    public static bool IsPowerStateSupported(PowerState powerState);
  }
}

API Removals:

namespace Windows.UI.Composition {
  public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
  }
}
namespace Windows.UI.Composition.Interactions {
  public sealed class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
  }
}

Windows 10 Anniversary SDK Preview Build 14388 Released

Today, we released a new Windows 10 Anniversary SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14388 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14388 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Things to note:

  • We are getting close to Windows 10 Anniversary Update on August 2nd, 2016. It is a great time to start testing end to end with all the new APIs Windows 10 Anniversary Update provides.
  • This is still a pre-release build of the SDK. While the EULA does state this is an RTM release, it is not. This release does not have a go-live license. Apps built with this SDK will not be allowed to be on-boarded to the store.

What’s New since 14383

  • Minor bug fixes, no API delta changes

Windows 10 Anniversary SDK Preview Build 14366 Released

Today, we released a new Windows 10 Anniversary SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14366 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14366 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Things to note

  • We have fixed the issue with the Desktop App Converter Preview (Project Centennial) however you will need to download the updated version at http://aka.ms/converter.

What’s New

namespace Windows.ApplicationModel.Core {
  public static class CoreApplication {
    public static void EnablePrelaunch(bool value);
  }
}
namespace Windows.Gaming.Input.ForceFeedback {
  public enum ConditionForceEffectKind {
    Inertia = 2,
  }
  public sealed class ConstantForceEffect : IForceFeedbackEffect {
    public ConstantForceEffect();
  }
  public sealed class RampForceEffect : IForceFeedbackEffect {
    public RampForceEffect();
  }
}
namespace Windows.Media.Protection {
  public sealed class ProtectionCapabilities {
    public ProtectionCapabilities();
  }
}
namespace Windows.Media.Protection.PlayReady {
  public sealed class PlayReadyLicenseAcquisitionServiceRequest : IMediaProtectionServiceRequest, IPlayReadyLicenseAcquisitionServiceRequest, IPlayReadyServiceRequest {
    Guid SessionId { get; }
  }
}
namespace Windows.UI.Input {
  public sealed class RadialController {
    event TypedEventHandler<RadialController, RadialControllerButtonClickedEventArgs> ButtonClicked;
    event TypedEventHandler<RadialController, RadialControllerControlAcquiredEventArgs> ControlAcquired;
  }
  public sealed class RadialControllerButtonClickedEventArgs
  public sealed class RadialControllerControlAcquiredEventArgs
}
namespace Windows.UI.WebUI {
  public static class WebUIApplication {
    public static void EnablePrelaunch(bool value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public class ComboBoxAutomationPeer : SelectorAutomationPeer, IExpandCollapseProvider, IValueProvider, IWindowProvider {
    WindowInteractionState InteractionState { get; }
    bool IsModal { get; }
    bool IsTopmost { get; }
    bool Maximizable { get; }
    bool Minimizable { get; }
    WindowVisualState VisualState { get; }
    void Close();
    void SetVisualState(WindowVisualState state);
    bool WaitForInputIdle(int milliseconds);
  }
}

Removed APIs

namespace Windows.Gaming.Input.ForceFeedback {
  public enum ConditionForceEffectKind {
    Interia = 2,
  }
}

Windows 10 Anniversary SDK Preview Build 14332 Released

Today, we released a new Windows 10 Anniversary SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14332 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14332 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Known issues

  • Desktop App Converter
    • The Desktop App Converter Preview (Project Centennial) will fail to run on the Windows 10 Insider Preview Build 14332. If you are a developer utilizing the converter tool to convert your desktop app to UWP, we suggest skipping Build 14332 until we can fix this issue.
  • Emulator
    • Known issue that currently blocks our users from injecting fake location data to their UWP applications running in the emulator

What’s New

This Windows SDK includes the following updates and additions to the Windows namespace since Preview SDK Build 14295. We sadly didn’t do a changelog for 14267 to 14295.

namespace Windows.ApplicationModel {
  public sealed class EnteredBackgroundEventArgs : IEnteredBackgroundEventArgs
  public interface IEnteredBackgroundEventArgs
  public interface ILeavingBackgroundEventArgs
  public sealed class LeavingBackgroundEventArgs : ILeavingBackgroundEventArgs
  public sealed class Package {
    IAsyncOperation<bool> VerifyContentIntegrityAsync();
  }
  public sealed class PackageCatalog
  public sealed class PackageInstallingEventArgs
  public sealed class PackageStagingEventArgs
  public sealed class PackageStatusChangedEventArgs
  public sealed class PackageUninstallingEventArgs
  public sealed class PackageUpdatingEventArgs
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    FilePickerExperience = 1015,
    UserDataAccountsProvider = 1014,
  }
  public sealed class AppointmentsProviderAddAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderAddAppointmentActivatedEventArgs {
    User User { get; }
  }
  public sealed class AppointmentsProviderRemoveAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderRemoveAppointmentActivatedEventArgs {
    User User { get; }
  }
  public sealed class AppointmentsProviderReplaceAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderReplaceAppointmentActivatedEventArgs {
    User User { get; }
  }
  public sealed class AppointmentsProviderShowAppointmentDetailsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
    User User { get; }
  }
  public sealed class AppointmentsProviderShowTimeFrameActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowTimeFrameActivatedEventArgs {
    User User { get; }
  }
  public sealed class BackgroundActivatedEventArgs : IBackgroundActivatedEventArgs
  public sealed class CachedFileUpdaterActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ICachedFileUpdaterActivatedEventArgs {
    User User { get; }
  }
  public sealed class DeviceActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDeviceActivatedEventArgs, IViewSwitcherProvider {
    User User { get; }
  }
  public sealed class DevicePairingActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IDevicePairingActivatedEventArgs {
    User User { get; }
  }
  public sealed class DialReceiverActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDialReceiverActivatedEventArgs, ILaunchActivatedEventArgs, IViewSwitcherProvider {
    User User { get; }
  }
  public sealed class FileActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IFileActivatedEventArgs, IFileActivatedEventArgsWithCallerPackageFamilyName, IFileActivatedEventArgsWithNeighboringFiles, IViewSwitcherProvider {
    User User { get; }
  }
  public sealed class FileOpenPickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IFileOpenPickerActivatedEventArgs, IFileOpenPickerActivatedEventArgs2 {
    User User { get; }
  }
  public sealed class FileOpenPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileOpenPickerContinuationEventArgs {
    User User { get; }
  }
  public sealed class FileSavePickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IFileSavePickerActivatedEventArgs, IFileSavePickerActivatedEventArgs2 {
    User User { get; }
  }
  public sealed class FileSavePickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileSavePickerContinuationEventArgs {
    User User { get; }
  }
  public sealed class FolderPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFolderPickerContinuationEventArgs {
    User User { get; }
  }
  public interface IActivatedEventArgsWithUser : IActivatedEventArgs
  public interface IBackgroundActivatedEventArgs
  public interface ILaunchActivatedEventArgs2 : IActivatedEventArgs, ILaunchActivatedEventArgs
  public interface IUserDataAccountProviderActivatedEventArgs : IActivatedEventArgs
  public sealed class LaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, ILaunchActivatedEventArgs2, IPrelaunchActivatedEventArgs, IViewSwitcherProvider {
    TileActivatedInfo TileActivatedInfo { get; }
    User User { get; }
  }
  public sealed class LockScreenActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ILockScreenActivatedEventArgs {
    User User { get; }
  }
  public sealed class ProtocolActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IViewSwitcherProvider {
    User User { get; }
  }
  public sealed class ProtocolForResultsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IProtocolForResultsActivatedEventArgs, IViewSwitcherProvider {
    User User { get; }
  }
  public sealed class RestrictedLaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IRestrictedLaunchActivatedEventArgs {
    User User { get; }
  }
  public sealed class SearchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ISearchActivatedEventArgs, ISearchActivatedEventArgsWithLinguisticDetails, IViewSwitcherProvider {
    User User { get; }
  }
  public sealed class ShareTargetActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IShareTargetActivatedEventArgs {
    User User { get; }
  }
  public sealed class TileActivatedInfo
  public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IToastNotificationActivatedEventArgs {
    User User { get; }
  }
  public sealed class UserDataAccountProviderActivatedEventArgs : IActivatedEventArgs, IUserDataAccountProviderActivatedEventArgs
  public sealed class VoiceCommandActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IVoiceCommandActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebAccountProviderActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IWebAccountProviderActivatedEventArgs {
    User User { get; }
  }
}
namespace Windows.ApplicationModel.Appointments {
  public enum AppointmentCalendarOtherAppReadAccess {
    None = 3,
  }
  public static class AppointmentManager {
    public static AppointmentManagerForUser GetForUser(User user);
  }
  public sealed class AppointmentManagerForUser
}
namespace Windows.ApplicationModel.AppService {
  public sealed class AppServiceConnection : IClosable {
    User User { get; set; }
    IAsyncOperation<AppServiceConnectionStatus> OpenRemoteAsync(RemoteSystemConnectionRequest remoteSystemConnectionRequest);
  }
  public enum AppServiceConnectionStatus {
    NotAuthorized = 7,
    RemoteSystemNotSupportedByApp = 6,
    RemoteSystemUnavailable = 5,
  }
  public enum AppServiceResponseStatus {
    MessageSizeTooLarge = 5,
    RemoteSystemUnavailable = 4,
  }
  public sealed class AppServiceTriggerDetails {
    bool IsRemoteSystemConnection { get; }
  }
}
namespace Windows.ApplicationModel.Background {
  public enum BackgroundAccessStatus {
    AllowedSubjectToSystemPolicy = 5,
    AlwaysAllowed = 4,
    DeniedBySystemPolicy = 6,
    DeniedByUser = 7,
  }
  public interface IBackgroundTaskInstance4 : IBackgroundTaskInstance
  public sealed class SecondaryAuthenticationFactorAuthenticationTrigger : IBackgroundTrigger
  public sealed class SocketActivityTrigger : IBackgroundTrigger {
    bool IsWakeFromLowPowerSupported { get; }
  }
  public enum SystemTriggerType {
    DefaultSignInAccountChange = 15,
  }
  public sealed class UserNotificationChangedTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
  public static class PhoneCallHistoryManager {
    public static PhoneCallHistoryManagerForUser GetForUser(User user);
  }
  public sealed class PhoneCallHistoryManagerForUser
}
namespace Windows.ApplicationModel.Chat {
  public sealed class ChatConversation : IChatItem {
    ChatItemKind ItemKind { get; }
  }
  public sealed class ChatMessage : IChatItem {
    ChatItemKind ItemKind { get; }
  }
}
namespace Windows.ApplicationModel.Core {
  public static class CoreApplication {
    public static event EventHandler<BackgroundActivatedEventArgs> BackgroundActivated;
    public static event EventHandler<EnteredBackgroundEventArgs> EnteredBackground;
    public static event EventHandler<LeavingBackgroundEventArgs> LeavingBackground;
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataTransferManager {
    public static bool IsSupported();
  }
}
namespace Windows.ApplicationModel.Email {
  public enum EmailMailboxOtherAppReadAccess {
    None = 2,
  }
  public static class EmailManager {
    public static EmailManagerForUser GetForUser(User user);
  }
  public sealed class EmailManagerForUser
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
  public static class LicenseManager {
    public static IAsyncOperation<LicenseSatisfactionResult> GetSatisfactionInfosAsync(IIterable<string> contentIds, IIterable<string> keyIds);
  }
  public sealed class LicenseSatisfactionInfo
  public sealed class LicenseSatisfactionResult
}
namespace Windows.ApplicationModel.Store.Preview {
  public static class StoreConfiguration {
    public static IReference<uint> GetPurchasePromptingPolicyForUser(User user);
    public static IAsyncOperation<IRandomAccessStreamReference> GetStoreLogDataAsync(StoreLogOptions options);
    public static bool HasStoreWebAccount();
    public static bool HasStoreWebAccountForUser(User user);
    public static bool IsStoreWebAccountIdForUser(User user, string webAccountId);
    public static void SetPurchasePromptingPolicyForUser(User user, IReference<uint> value);
    public static void SetStoreWebAccountIdForUser(User user, string webAccountId);
  }
  public enum StoreLogOptions : uint
  public enum StoreSystemFeature {
    Memory12GB = 27,
    Memory16GB = 28,
    Memory20GB = 29,
    Memory4GB = 24,
    Memory6GB = 25,
    Memory8GB = 26,
    VideoMemory2GB = 30,
    VideoMemory4GB = 31,
    VideoMemory6GB = 32,
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallManager {
    IAsyncOperation<bool> GetIsAppAllowedToInstallForUserAsync(User user, string productId, string skuId, string catalogId, string correlationVector);
    IAsyncOperation<bool> GetIsApplicableForUserAsync(User user, string productId, string skuId);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync(User user, string correlationVector);
    IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync(User user, string productId, string skuId, string catalogId, string correlationVector);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync(string productId, string catalogId, string flightId, string clientId, bool repair, bool forceUseOfNonRemovableStorage, string correlationVector, PackageVolume targetVolume);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync(User user, string productId, string catalogId, string flightId, string clientId, bool repair, bool forceUseOfNonRemovableStorage, string correlationVector, PackageVolume targetVolume);
    IAsyncOperation<AppInstallItem> UpdateAppByPackageFamilyNameForUserAsync(User user, string packageFamilyName, string correlationVector);
  }
  public sealed class AppInstallStatus {
    bool ReadyForLaunch { get; }
    User User { get; }
  }
}
namespace Windows.ApplicationModel.UserDataAccounts {
  public sealed class UserDataAccount {
    string DisplayName { get; set; }
    IVector<string> ExplictReadAccessPackageFamilyNames { get; }
  }
  public static class UserDataAccountManager {
    public static UserDataAccountManagerForUser GetForUser(User user);
  }
  public sealed class UserDataAccountManagerForUser
  public enum UserDataAccountOtherAppReadAccess {
    None = 2,
  }
}
namespace Windows.ApplicationModel.UserDataAccounts.Provider {
  public interface IUserDataAccountProviderOperation
  public sealed class UserDataAccountPartnerAccountInfo
  public sealed class UserDataAccountProviderAddAccountOperation : IUserDataAccountProviderOperation
  public enum UserDataAccountProviderOperationKind
  public enum UserDataAccountProviderPartnerAccountKind
  public sealed class UserDataAccountProviderResolveErrorsOperation : IUserDataAccountProviderOperation
  public sealed class UserDataAccountProviderSettingsOperation : IUserDataAccountProviderOperation
}
namespace Windows.ApplicationModel.UserDataAccounts.SystemAccess {
  public sealed class DeviceAccountConfiguration {
    bool IsSyncScheduleManagedBySystem { get; set; }
  }
  public static class UserDataAccountSystemAccessManager {
    public static IAsyncAction SuppressLocalAccountWithAccountAsync(string userDataAccountId);
  }
}
namespace Windows.Data.Text {
  public sealed class TextPhoneme
  public sealed class TextReverseConversionGenerator {
    IAsyncOperation<IVectorView<TextPhoneme>> GetPhonemesAsync(string input);
  }
}
namespace Windows.Devices.AllJoyn {
  public enum AllJoynAuthenticationMechanism {
    EcdheSpeke = 6,
  }
  public sealed class AllJoynBusAttachment {
    event TypedEventHandler<AllJoynBusAttachment, AllJoynAcceptSessionJoinerEventArgs> AcceptSessionJoinerRequested;
    event TypedEventHandler<AllJoynBusAttachment, AllJoynSessionJoinedEventArgs> SessionJoined;
    IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync(AllJoynServiceInfo serviceInfo);
    IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync(AllJoynServiceInfo serviceInfo, Language language);
    public static AllJoynBusAttachment GetDefault();
    public static DeviceWatcher GetWatcher(IIterable<string> requiredInterfaces);
  }
  public sealed class AllJoynBusObject
  public sealed class AllJoynBusObjectStoppedEventArgs
  public sealed class AllJoynServiceInfo {
    public static IAsyncOperation<AllJoynServiceInfo> FromIdAsync(string deviceId);
  }
  public sealed class AllJoynSession
  public sealed class AllJoynSessionJoinedEventArgs
  public interface IAllJoynProducer
}
namespace Windows.Devices.Enumeration {
  public sealed class EnclosureLocation {
    uint RotationAngleInDegreesClockwise { get; }
  }
}
namespace Windows.Devices.Geolocation {
  public sealed class Geolocator {
    void AllowFallbackToConsentlessPositions();
  }
  public enum PositionSource {
    Obfuscated = 6,
  }
}
namespace Windows.Devices.HumanInterfaceDevice {
  public sealed class HidBooleanControlDescription {
    bool IsAbsolute { get; }
  }
}
namespace Windows.Devices.Midi {
  public enum MidiMessageType {
    EndSystemExclusive = 247,
  }
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScanner {
    string VideoDeviceId { get; }
  }
}
namespace Windows.Devices.Sensors {
  public sealed class Accelerometer {
    AccelerometerReadingType ReadingType { get; }
    public static Accelerometer GetDefault(AccelerometerReadingType readingType);
  }
  public enum AccelerometerReadingType
  public sealed class Inclinometer {
    public static Inclinometer GetDefault(SensorReadingType sensorReadingtype);
  }
  public sealed class OrientationSensor {
    public static OrientationSensor GetDefault(SensorReadingType sensorReadingtype);
    public static OrientationSensor GetDefault(SensorReadingType sensorReadingType, SensorOptimizationGoal optimizationGoal);
  }
  public enum SensorOptimizationGoal
}
namespace Windows.Devices.SmartCards {
  public enum SmartCardReaderKind {
    EmbeddedSE = 5,
  }
}
namespace Windows.Foundation.Metadata {
  public sealed class CreateFromStringAttribute : Attribute
}
namespace Windows.Gaming.Input {
  public sealed class ArcadeStick : IGameController
  public enum ArcadeStickButtons : uint
  public struct ArcadeStickReading
  public enum GameControllerButtonLabel
  public sealed class Gamepad : IGameController {
    GameControllerButtonLabel GetButtonLabel(GamepadButtons button);
  }
  public enum GamepadButtons : uint {
    Paddle1 = (uint)16384,
    Paddle2 = (uint)32768,
    Paddle3 = (uint)65536,
    Paddle4 = (uint)131072,
  }
  public enum OptionalUINavigationButtons : uint
  public sealed class RacingWheel : IGameController
  public enum RacingWheelButtons : uint
  public struct RacingWheelReading
  public enum RequiredUINavigationButtons : uint
  public sealed class UINavigationController : IGameController
  public struct UINavigationReading
}
namespace Windows.Gaming.Input.ForceFeedback {
  public sealed class ConditionForceEffect : IForceFeedbackEffect
  public enum ConditionForceEffectKind
  public sealed class ConstantForceEffect : IForceFeedbackEffect
  public enum ForceFeedbackEffectAxes : uint
  public enum ForceFeedbackEffectState
  public enum ForceFeedbackLoadEffectResult
  public sealed class ForceFeedbackMotor
  public interface IForceFeedbackEffect
  public sealed class PeriodicForceEffect : IForceFeedbackEffect
  public enum PeriodicForceEffectKind
  public sealed class RampForceEffect : IForceFeedbackEffect
}
namespace Windows.Globalization {
  public static class CalendarIdentifiers {
    public static string ChineseLunar { get; }
    public static string JapaneseLunar { get; }
    public static string KoreanLunar { get; }
    public static string TaiwanLunar { get; }
    public static string VietnameseLunar { get; }
  }
}
namespace Windows.Globalization.PhoneNumberFormatting {
  public enum PhoneNumberFormat
  public sealed class PhoneNumberFormatter
  public sealed class PhoneNumberInfo : IStringable
  public enum PhoneNumberMatchResult
  public enum PhoneNumberParseResult
  public enum PredictedPhoneNumberKind
}
namespace Windows.Graphics.Display {
  public sealed class DisplayInformation {
    uint ScreenHeightInRawPixels { get; }
    uint ScreenWidthInRawPixels { get; }
  }
}
namespace Windows.Graphics.Printing {
  public sealed class PrintManager {
    public static bool IsSupported();
  }
  public sealed class PrintPageInfo
  public sealed class PrintTaskOptions : IPrintTaskOptionsCore, IPrintTaskOptionsCoreProperties, IPrintTaskOptionsCoreUIConfiguration {
    IRandomAccessStream GetPagePrintTicket(PrintPageInfo printPageInfo);
  }
}
namespace Windows.Management.Workplace {
  public static class MdmPolicy {
    public static MessagingSyncPolicy GetMessagingSyncPolicy();
  }
  public enum MessagingSyncPolicy
}
namespace Windows.Media {
  public sealed class MusicDisplayProperties {
    uint AlbumTrackCount { get; set; }
  }
}
namespace Windows.Media.Audio {
  public sealed class AudioDeviceOutputNode : IAudioNode, IAudioNodeWithListener, IClosable
  public sealed class AudioFileOutputNode : IAudioNode, IClosable
  public sealed class AudioFrameOutputNode : IAudioNode, IClosable
  public sealed class AudioNodeEmitter {
    bool IsDopplerDisabled { get; }
  }
  public interface IAudioNodeWithListener : IAudioNode, IClosable
}
namespace Windows.Media.Capture {
  public sealed class LowLagMediaRecording {
    IAsyncOperation<MediaCapturePauseResult> PauseWithResultAsync(MediaCapturePauseBehavior behavior);
    IAsyncOperation<MediaCaptureStopResult> StopWithResultAsync();
  }
  public sealed class MediaCapture : IClosable {
    IMapView<string, MediaFrameSource> FrameSources { get; }
    IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync(MediaFrameSource inputSource);
    IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync(MediaFrameSource inputSource, string outputSubtype);
    IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync(MediaFrameSource inputSource, string outputSubtype, BitmapSize outputSize);
    IAsyncOperation<MediaCapturePauseResult> PauseRecordWithResultAsync(MediaCapturePauseBehavior behavior);
    IAsyncOperation<MediaCaptureStopResult> StopRecordWithResultAsync();
  }
  public sealed class MediaCaptureInitializationSettings {
    MediaCaptureMemoryPreference MemoryPreference { get; set; }
    MediaCaptureSharingMode SharingMode { get; set; }
    MediaFrameSourceGroup SourceGroup { get; set; }
  }
  public enum MediaCaptureMemoryPreference
  public sealed class MediaCapturePauseResult : IClosable
  public enum MediaCaptureSharingMode
  public sealed class MediaCaptureStopResult : IClosable
}
namespace Windows.Media.Capture.Frames {
  public sealed class BufferMediaFrame
  public sealed class DepthMediaFrame
  public sealed class DepthMediaFrameFormat
  public sealed class InfraredMediaFrame
  public sealed class MediaFrameArrivedEventArgs
  public sealed class MediaFrameFormat
  public sealed class MediaFrameReader : IClosable
  public enum MediaFrameReaderStartStatus
  public sealed class MediaFrameReference : IClosable
  public sealed class MediaFrameSource
  public sealed class MediaFrameSourceController
  public sealed class MediaFrameSourceGetPropertyResult
  public enum MediaFrameSourceGetPropertyStatus
  public sealed class MediaFrameSourceGroup
  public sealed class MediaFrameSourceInfo
  public enum MediaFrameSourceKind
  public enum MediaFrameSourceSetPropertyStatus
  public sealed class VideoMediaFrame
  public sealed class VideoMediaFrameFormat
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor {
    IReference<uint> LeadingEncoderPadding { get; set; }
    IReference<uint> TrailingEncoderPadding { get; set; }
  }
  public sealed class MediaStreamSource : IMediaSource {
    event TypedEventHandler<MediaStreamSource, MediaStreamSourceSampleRenderedEventArgs> SampleRendered;
  }
  public sealed class MediaStreamSourceSampleLag
  public sealed class MediaStreamSourceSampleLagOccuredEventArgs
}
namespace Windows.Media.Devices.Core {
  public sealed class CameraIntrinsics {
    Matrix4x4 UndistortedProjectionTransform { get; }
    Point DistortPoint(Point input);
    void DistortPoints(Point[] inputs, Point[] results);
    Point UndistortPoint(Point input);
    void UndistortPoints(Point[] inputs, Point[] results);
  }
  public sealed class DepthCorrelatedCoordinateMapper : IClosable
}
namespace Windows.Media.MediaProperties {
  public enum StereoscopicVideoPackingMode
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    StereoscopicVideoPackingMode StereoscopicVideoPackingMode { get; }
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaBreakManager {
    MediaPlaybackSession PlaybackSession { get; }
  }
  public enum MediaCommandEnablingRule
  public sealed class MediaPlaybackCommandManager {
    MediaPlaybackCommandManagerCommandBehavior AutoRepeatModeBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior FastForwardBehavior { get; }
    MediaPlayer MediaPlayer { get; }
    MediaPlaybackCommandManagerCommandBehavior NextBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior PauseBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior PlayBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior PositionBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior PreviousBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior RateBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior RewindBehavior { get; }
    MediaPlaybackCommandManagerCommandBehavior ShuffleBehavior { get; }
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs> AutoRepeatModeReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerFastForwardReceivedEventArgs> FastForwardReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerNextReceivedEventArgs> NextReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPauseReceivedEventArgs> PauseReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, PlaybackPositionCommandReceivedEventArgs> PlaybackPositionCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, PlaybackRateCommandReceivedEventArgs> PlaybackRateCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPlayReceivedEventArgs> PlayReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPositionReceivedEventArgs> PositionReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPreviousReceivedEventArgs> PreviousReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerRateReceivedEventArgs> RateReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerRewindReceivedEventArgs> RewindReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerShuffleReceivedEventArgs> ShuffleReceived;
  }
  public sealed class MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerCommandBehavior
  public sealed class MediaPlaybackCommandManagerFastForwardReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerNextReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerPauseReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerPlayReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerPositionReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerPreviousReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerRateReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerRewindReceivedEventArgs
  public sealed class MediaPlaybackCommandManagerShuffleReceivedEventArgs
  public sealed class MediaPlaybackItem : IMediaPlaybackSource {
    void ApplyDisplayProperties(MediaItemDisplayProperties value);
    MediaItemDisplayProperties GetDisplayProperties();
  }
  public sealed class MediaPlaybackSession
  public enum MediaPlaybackState
  public sealed class MediaPlayer : IClosable {
    double AudioBalance { get; set; }
    MediaPlaybackSession PlaybackSession { get; }
    StereoscopicVideoRenderMode StereoscopicVideoRenderMode { get; set; }
    event TypedEventHandler<MediaPlayer, object> IsMutedChanged;
    event TypedEventHandler<MediaPlayer, object> SourceChanged;
    void AddVideoEffect(string activatableClassId, bool effectOptional, IPropertySet effectConfiguration);

    MediaPlayerSurface GetSurface(Compositor compositor);
    void SetSurfaceSize(Size size);
    void StepBackwardOneFrame();
    void StepForwardOneFrame();
  }
  public sealed class MediaPlayerSurface : IClosable
  public enum StereoscopicVideoRenderMode
}
namespace Windows.Media.Protection {
  public enum HdcpProtection
  public sealed class HdcpSession : IClosable
  public enum HdcpSetProtectionResult
}
namespace Windows.Media.Protection.PlayReady {
  public static class PlayReadyStatics {
    public static string InputTrustAuthorityToCreate { get; }
    public static Guid ProtectionSystemId { get; }
  }
}
namespace Windows.Networking.NetworkOperators {
  public sealed class NetworkOperatorTetheringManager {
    public static NetworkOperatorTetheringManager CreateFromConnectionProfile(ConnectionProfile profile, NetworkAdapter adapter);
  }
  public enum TetheringOperationStatus {
    BluetoothDeviceOff = 7,
    NetworkLimitedConnectivity = 8,
  }
}
namespace Windows.Networking.PushNotifications {
  public static class PushNotificationChannelManager {
    public static PushNotificationChannelManagerForUser GetForUser(User user);
  }
  public sealed class PushNotificationChannelManagerForUser
}
namespace Windows.Networking.Sockets {
  public interface IWebSocketControl2 : IWebSocketControl
  public interface IWebSocketInformation2 : IWebSocketInformation
  public sealed class MessageWebSocket : IClosable, IWebSocket {
    event TypedEventHandler<MessageWebSocket, WebSocketServerCustomValidationRequestedEventArgs> ServerCustomValidationRequested;
  }
  public sealed class MessageWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
  }
  public sealed class MessageWebSocketInformation : IWebSocketInformation, IWebSocketInformation2 {
    Certificate ServerCertificate { get; }
    IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
    SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
    IVectorView<Certificate> ServerIntermediateCertificates { get; }
  }
  public sealed class StreamSocket : IClosable {
    public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync(HostName remoteHostName, string remoteServiceName);
    public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync(HostName remoteHostName, string remoteServiceName, HostNameSortOptions sortOptions);
  }
  public sealed class StreamWebSocket : IClosable, IWebSocket {
    event TypedEventHandler<StreamWebSocket, WebSocketServerCustomValidationRequestedEventArgs> ServerCustomValidationRequested;
  }
  public sealed class StreamWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
  }
  public sealed class StreamWebSocketInformation : IWebSocketInformation, IWebSocketInformation2 {
    Certificate ServerCertificate { get; }
    IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
    SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
    IVectorView<Certificate> ServerIntermediateCertificates { get; }
  }
  public sealed class WebSocketServerCustomValidationRequestedEventArgs
}
namespace Windows.Networking.Vpn {
  public sealed class VpnDomainNameInfo {
    IVector<Uri> WebProxyUris { get; }
  }
  public enum VpnManagementConnectionStatus
  public enum VpnManagementErrorStatus {
    AlreadyConnected = 8,
    AlreadyDisconnecting = 7,
    CannotFindProfile = 6,
    CertificateFailure = 12,
    DnsNotResolvable = 17,
    EapFailure = 10,
    GeneralAuthenticationFailure = 9,
    InvalidIP = 18,
    NoConnection = 14,
    ServerConfiguration = 13,
    ServerConnection = 15,
    SmartCardFailure = 11,
    UserNamePassword = 16,
  }
  public sealed class VpnNativeProfile : IVpnProfile {
    VpnManagementConnectionStatus ConnectionStatus { get; }
    bool RequireVpnClientAppUI { get; set; }
  }
  public sealed class VpnPlugInProfile : IVpnProfile {
    VpnManagementConnectionStatus ConnectionStatus { get; }
    bool RequireVpnClientAppUI { get; set; }
  }
}
namespace Windows.Security.Authentication.Identity.Core {
  public sealed class MicrosoftAccountMultiFactorAuthenticationManager {
    IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus, string userAccountId, string sessionId, MicrosoftAccountMultiFactorAuthenticationType sessionAuthenticationType);
    IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus, MicrosoftAccountMultiFactorSessionInfo authenticationSessionInfo);
  }
  public enum MicrosoftAccountMultiFactorServiceResponse {
    DeviceIdChanged = 21,
    DeviceNotFound = 14,
    FlowDisabled = 15,
    InvalidOperation = 12,
    InvalidSessionId = 10,
    InvalidSessionType = 11,
    InvalidStateTransition = 13,
    NgcDisabledByServer = 18,
    NgcKeyNotFoundOnServer = 19,
    NgcNonceExpired = 9,
    NgcNotSetup = 5,
    OperationCanceledByUser = 17,
    SessionAlreadyApproved = 7,
    SessionAlreadyDenied = 6,
    SessionExpired = 8,
    SessionNotApproved = 16,
    UIRequired = 20,
  }
  public enum MicrosoftAccountMultiFactorSessionApprovalStatus {
    Denied = 2,
  }
}
namespace Windows.Security.Authentication.Identity.Provider {
  public sealed class SecondaryAuthenticationFactorAuthentication
  public enum SecondaryAuthenticationFactorAuthenticationMessage
  public sealed class SecondaryAuthenticationFactorAuthenticationResult
  public enum SecondaryAuthenticationFactorAuthenticationScenario
  public enum SecondaryAuthenticationFactorAuthenticationStage
  public sealed class SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs
  public sealed class SecondaryAuthenticationFactorAuthenticationStageInfo
  public enum SecondaryAuthenticationFactorAuthenticationStatus
  public enum SecondaryAuthenticationFactorDeviceCapabilities : uint
  public enum SecondaryAuthenticationFactorDeviceFindScope
  public enum SecondaryAuthenticationFactorFinishAuthenticationStatus
  public sealed class SecondaryAuthenticationFactorInfo
  public sealed class SecondaryAuthenticationFactorRegistration
  public sealed class SecondaryAuthenticationFactorRegistrationResult
  public enum SecondaryAuthenticationFactorRegistrationStatus
}
namespace Windows.Storage {
  public sealed class StorageLibrary {
    StorageLibraryChangeTracker ChangeTracker { get; }
  }
  public sealed class StorageLibraryChange
  public sealed class StorageLibraryChangeReader
  public sealed class StorageLibraryChangeTracker
  public enum StorageLibraryChangeType
}
namespace Windows.System {
  public enum AppMemoryUsageLevel {
    OverLimit = 3,
  }
  public static class Launcher {
    public static IAsyncOperation<IVectorView<AppInfo>> FindAppUriHandlersAsync(Uri uri);
    public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync(Uri uri);
    public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync(Uri uri, string packageFamilyName);
  }
  public sealed class LauncherOptions : ILauncherViewOptions {
    bool IgnoreAppUriHandlers { get; set; }
  }
  public static class RemoteLauncher
  public sealed class RemoteLauncherOptions
  public enum RemoteLaunchUriStatus
  public static class UserDeviceAssociation
  public sealed class UserDeviceAssociationChangedEventArgs
  public sealed class UserPicker
}
namespace Windows.System.Profile {
  public static class SystemIdentification
  public sealed class SystemIdentificationInfo
  public enum SystemIdentificationSource
}
namespace Windows.System.RemoteSystems {
  public interface IRemoteSystemFilter
  public sealed class RemoteSystem
  public enum RemoteSystemAccessStatus
  public sealed class RemoteSystemAddedEventArgs
  public sealed class RemoteSystemConnectionRequest
  public enum RemoteSystemDiscoveryType
  public sealed class RemoteSystemDiscoveryTypeFilter : IRemoteSystemFilter
  public sealed class RemoteSystemKindFilter : IRemoteSystemFilter
  public static class RemoteSystemKinds
  public sealed class RemoteSystemRemovedEventArgs
  public enum RemoteSystemStatus
  public enum RemoteSystemStatusType
  public sealed class RemoteSystemStatusTypeFilter : IRemoteSystemFilter
  public sealed class RemoteSystemUpdatedEventArgs
  public sealed class RemoteSystemWatcher
}
namespace Windows.System.UserProfile {
  public static class AdvertisingManager {
    public static AdvertisingManagerForUser GetForUser(User user);
  }
  public sealed class AdvertisingManagerForUser
}
namespace Windows.UI.ApplicationSettings {
  public sealed class AccountsSettingsPane {
    public static IAsyncAction ShowAddAccountAsync();
    public static IAsyncAction ShowManageAccountsAsync();
  }
}
namespace Windows.UI.Composition {
  public sealed class AmbientLight : CompositionLight
  public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
    string Target { get; set; }
    void SetBooleanParameter(string key, bool value);
  }
  public sealed class CompositionAnimationGroup : CompositionObject, ICompositionAnimationBase, IIterable<CompositionAnimation>
  public sealed class CompositionBackdropBrush : CompositionBrush
  public class CompositionLight : CompositionObject
  public sealed class CompositionNineGridBrush : CompositionBrush
  public class CompositionObject : IClosable {
    string Comment { get; set; }
    ImplicitAnimationCollection ImplicitAnimations { get; set; }
    void StartAnimationGroup(ICompositionAnimationBase value);
    void StopAnimationGroup(ICompositionAnimationBase value);
  }
  public sealed class CompositionPropertyChangedEventArgs : CompositionObject
  public sealed class CompositionPropertySet : CompositionObject {
    void InsertBoolean(string propertyName, bool value);
    CompositionGetValueStatus TryGetBoolean(string propertyName, out bool value);
  }
  public sealed class Compositor : IClosable {
    AmbientLight CreateAmbientLight();
    AnimationGroup CreateAnimationGroup();
    CompositionAnimationGroup CreateAnimationGroup();
    CompositionBackdropBrush CreateBackdropBrush();
    CompositionDestinationBrush CreateDestinationBrush();
    DistantLight CreateDistantLight();
    ImplicitAnimationCollection CreateImplicitAnimationCollection();
    LayerVisual CreateLayerVisual();
    CompositionNineGridBrush CreateNineGridBrush();
    PointLight CreatePointLight();
    SpotLight CreateSpotLight();
  }
  public sealed class DistantLight : CompositionLight
  public sealed class DropShadow : CompositionShadow {
    float Opacity { get; set; }
  }
  public interface ICompositionAnimationBase
  public sealed class ImplicitAnimationCollection : CompositionObject, IIterable<IKeyValuePair<string, ICompositionAnimationBase>>, IMap<string, ICompositionAnimationBase>
  public class KeyFrameAnimation : CompositionAnimation {
  }
  public sealed class LayerVisual : ContainerVisual
  public sealed class PointLight : CompositionLight
  public sealed class SpotLight : CompositionLight
  public sealed class StepEasingFunction : CompositionEasingFunction {
    int FinalStep { get; set; }
    int InitialStep { get; set; }
    bool IsFinalStepSingleFrame { get; set; }
    bool IsInitialStepSingleFrame { get; set; }
  }
  public sealed class VisualUnorderedCollection : CompositionObject, IIterable<Visual>
}
namespace Windows.UI.Composition.Effects {
  public sealed class SceneLightingEffect : IGraphicsEffect, IGraphicsEffectSource
}
namespace Windows.UI.Composition.Interactions {
  public sealed class CompositionInteractionSourceCollection : CompositionObject, IIterable<ICompositionInteractionSource>
  public interface ICompositionInteractionSource
  public interface IInteractionTrackerOwner
  public enum InteractionChainingMode
  public enum InteractionSourceMode
  public sealed class InteractionTracker : CompositionObject
  public sealed class InteractionTrackerCustomAnimationStateEnteredArgs
  public sealed class InteractionTrackerIdleStateEnteredArgs
  public class InteractionTrackerInertiaModifier : CompositionObject
  public sealed class InteractionTrackerInertiaMotion : InteractionTrackerInertiaModifier
  public sealed class InteractionTrackerInertiaRestingValue : InteractionTrackerInertiaModifier
  public sealed class InteractionTrackerInertiaStateEnteredArgs
  public sealed class InteractionTrackerInteractingStateEnteredArgs
  public sealed class InteractionTrackerRequestIgnoredArgs
  public sealed class InteractionTrackerValuesChangedArgs
  public sealed class VisualInteractionSource : CompositionObject, ICompositionInteractionSource
  public enum VisualInteractionSourceRedirectionMode
}
namespace Windows.UI.Core {
  public sealed class AcceleratorKeyEventArgs : ICoreWindowEventArgs {
    string DeviceId { get; }
  }
  public sealed class CoreComponentInputSource : ICoreInputSourceBase, ICorePointerInputSource {
    string GetCurrentKeyEventDeviceId();
  }
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    string GetCurrentKeyEventDeviceId();
  }
  public sealed class KeyEventArgs : ICoreWindowEventArgs {
    string DeviceId { get; }
  }
}
namespace Windows.UI.Input {
  public sealed class RadialController
  public sealed class RadialControllerConfiguration
  public sealed class RadialControllerMenu
  public sealed class RadialControllerMenuItem
  public enum RadialControllerMenuKnownIcon
  public sealed class RadialControllerRotationChangedEventArgs
  public sealed class RadialControllerScreenContact
  public sealed class RadialControllerScreenContactContinuedEventArgs
  public sealed class RadialControllerScreenContactStartedEventArgs
  public enum RadialControllerSystemMenuItemKind
}
namespace Windows.UI.Input.Inking {
  public interface IInkPresenterRulerFactory
  public interface IInkPresenterStencil
  public sealed class InkDrawingAttributes {
    InkDrawingAttributesKind Kind { get; }
    InkDrawingAttributesPencilProperties PencilProperties { get; }
    public static InkDrawingAttributes CreateForPencil();
  }
  public enum InkDrawingAttributesKind
  public sealed class InkDrawingAttributesPencilProperties
  public sealed class InkPresenterRuler : IInkPresenterStencil
  public enum InkPresenterStencilKind
}
namespace Windows.UI.Input.Inking.Core {
  public enum CoreWetStrokeDisposition
  public sealed class CoreWetStrokeUpdateEventArgs
  public sealed class CoreWetStrokeUpdateSource
}
namespace Windows.UI.Input.Preview.Injection {
  public enum InjectedInputButtonChangeKind
  public sealed class InjectedInputKeyboardInfo
  public enum InjectedInputKeyOptions : uint
  public sealed class InjectedInputMouseInfo
  public enum InjectedInputMouseOptions : uint
  public enum InjectedInputPenButtons : uint
  public sealed class InjectedInputPenInfo
  public enum InjectedInputPenParameters : uint
  public struct InjectedInputPoint
  public struct InjectedInputPointerInfo
  public enum InjectedInputPointerOptions : uint
  public struct InjectedInputRectangle
  public enum InjectedInputShortcut
  public sealed class InjectedInputTouchInfo
  public enum InjectedInputTouchParameters : uint
  public enum InjectedInputVisualizationMode
  public sealed class InputInjector
}
namespace Windows.UI.Notifications {
  public enum AdaptiveNotificationContentKind
  public sealed class AdaptiveNotificationText : IAdaptiveNotificationContent
  public static class BadgeUpdateManager {
    public static BadgeUpdateManagerForUser GetForUser(User user);
  }
  public sealed class BadgeUpdateManagerForUser
  public interface IAdaptiveNotificationContent
  public static class KnownAdaptiveNotificationHints
  public static class KnownAdaptiveNotificationTextStyles
  public static class KnownNotificationBindings
  public sealed class Notification
  public sealed class NotificationBinding
  public enum NotificationKinds : uint
  public enum NotificationMirroring
  public sealed class NotificationVisual
  public sealed class ScheduledToastNotification {
    NotificationMirroring NotificationMirroring { get; set; }
    string RemoteId { get; set; }
  }
  public sealed class ShownTileNotification
  public static class TileUpdateManager {
    public static TileUpdateManagerForUser GetForUser(User user);
  }
  public sealed class TileUpdateManagerForUser
  public sealed class ToastNotification {
    NotificationMirroring NotificationMirroring { get; set; }
    string RemoteId { get; set; }
  }
  public static class ToastNotificationManager {
    public static void ConfigureNotificationMirroring(NotificationMirroring value);
    public static ToastNotificationManagerForUser GetForUser(User user);
  }
  public sealed class ToastNotificationManagerForUser
  public sealed class UserNotification
  public sealed class UserNotificationChangedEventArgs
  public enum UserNotificationChangedKind
}
namespace Windows.UI.Notifications.Management {
  public sealed class UserNotificationListener
  public enum UserNotificationListenerAccessStatus
}
namespace Windows.UI.Text.Core {
  public enum CoreTextInputScope {
    ChatWithoutEmoji = 68,
  }
}
namespace Windows.UI.WebUI {
  public sealed class EnteredBackgroundEventArgs : IEnteredBackgroundEventArgs
  public delegate void EnteredBackgroundEventHandler(object sender, IEnteredBackgroundEventArgs e);
  public sealed class LeavingBackgroundEventArgs : ILeavingBackgroundEventArgs
  public delegate void LeavingBackgroundEventHandler(object sender, ILeavingBackgroundEventArgs e);
  public static class WebUIApplication {
    public static event EnteredBackgroundEventHandler EnteredBackground;
    public static event LeavingBackgroundEventHandler LeavingBackground;
  }
  public sealed class WebUIAppointmentsProviderAddAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderAddAppointmentActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIAppointmentsProviderRemoveAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderRemoveAppointmentActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIAppointmentsProviderReplaceAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderReplaceAppointmentActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIAppointmentsProviderShowAppointmentDetailsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIAppointmentsProviderShowTimeFrameActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowTimeFrameActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUICachedFileUpdaterActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, ICachedFileUpdaterActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIDeviceActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDeviceActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIDevicePairingActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IDevicePairingActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIDialReceiverActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDialReceiverActivatedEventArgs, ILaunchActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIFileActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IFileActivatedEventArgs, IFileActivatedEventArgsWithNeighboringFiles {
    User User { get; }
  }
  public sealed class WebUIFileOpenPickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IFileOpenPickerActivatedEventArgs, IFileOpenPickerActivatedEventArgs2 {
    User User { get; }
  }
  public sealed class WebUIFileOpenPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileOpenPickerContinuationEventArgs {
    User User { get; }
  }
  public sealed class WebUIFileSavePickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IFileSavePickerActivatedEventArgs, IFileSavePickerActivatedEventArgs2 {
    User User { get; }
  }
  public sealed class WebUIFileSavePickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileSavePickerContinuationEventArgs {
    User User { get; }
  }
  public sealed class WebUIFolderPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFolderPickerContinuationEventArgs {
    User User { get; }
  }
  public sealed class WebUILaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, IPrelaunchActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUILockScreenActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILockScreenActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIProtocolActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData {
    User User { get; }
  }
  public sealed class WebUIProtocolForResultsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IProtocolForResultsActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIRestrictedLaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IRestrictedLaunchActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIShareTargetActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IShareTargetActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IToastNotificationActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIUserDataAccountProviderActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IUserDataAccountProviderActivatedEventArgs
  public sealed class WebUIVoiceCommandActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IVoiceCommandActivatedEventArgs {
    User User { get; }
  }
  public sealed class WebUIWebAccountProviderActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IWebAccountProviderActivatedEventArgs {
    User User { get; }
  }
}
namespace Windows.UI.Xaml {
  public class Application {
    FocusVisualKind FocusVisualKind { get; set; }
    ApplicationRequiresPointerMode RequiresPointerMode { get; set; }
    event EnteredBackgroundEventHandler EnteredBackground;
    event LeavingBackgroundEventHandler LeavingBackground;
    virtual void OnBackgroundActivated(BackgroundActivatedEventArgs args);
  }
  public enum ApplicationRequiresPointerMode
  public sealed class DragEventArgs : RoutedEventArgs {
    DataPackageOperation AllowedOperations { get; }
  }
  public sealed class DragStartingEventArgs : RoutedEventArgs {
    DataPackageOperation AllowedOperations { get; set; }
  }
  public enum ElementSoundKind
  public enum ElementSoundMode
  public sealed class ElementSoundPlayer
  public enum ElementSoundPlayerState
  public delegate void EnteredBackgroundEventHandler(object sender, EnteredBackgroundEventArgs e);
  public enum FocusVisualKind
  public class FrameworkElement : UIElement {
    bool AllowFocusWhenDisabled { get; set; }
    public static DependencyProperty AllowFocusWhenDisabledProperty { get; }
    Thickness FocusVisualMargin { get; set; }
    public static DependencyProperty FocusVisualMarginProperty { get; }
    Brush FocusVisualPrimaryBrush { get; set; }
    public static DependencyProperty FocusVisualPrimaryBrushProperty { get; }
    Thickness FocusVisualPrimaryThickness { get; set; }
    public static DependencyProperty FocusVisualPrimaryThicknessProperty { get; }
    Brush FocusVisualSecondaryBrush { get; set; }
    public static DependencyProperty FocusVisualSecondaryBrushProperty { get; }
    Thickness FocusVisualSecondaryThickness { get; set; }
    public static DependencyProperty FocusVisualSecondaryThicknessProperty { get; }
  }
  public delegate void LeavingBackgroundEventHandler(object sender, LeavingBackgroundEventArgs e);
  public class UIElement : DependencyObject {
    bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
    public static DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public sealed class InkToolbarAutomationPeer : FrameworkElementAutomationPeer
  public class MediaPlayerElementAutomationPeer : FrameworkElementAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class AppBar : ContentControl {
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
    int DynamicOverflowOrder { get; set; }
    public static DependencyProperty DynamicOverflowOrderProperty { get; }
    bool IsInOverflow { get; }
    public static DependencyProperty IsInOverflowProperty { get; }
  }
  public class AppBarSeparator : Control, ICommandBarElement, ICommandBarElement2 {
    int DynamicOverflowOrder { get; set; }
    public static DependencyProperty DynamicOverflowOrderProperty { get; }
    bool IsInOverflow { get; }
    public static DependencyProperty IsInOverflowProperty { get; }
  }
  public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
    int DynamicOverflowOrder { get; set; }
    public static DependencyProperty DynamicOverflowOrderProperty { get; }
    bool IsInOverflow { get; }
    public static DependencyProperty IsInOverflowProperty { get; }
  }
  public sealed class AutoSuggestBox : ItemsControl {
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public class CalendarDatePicker : Control {
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public class ComboBox : Selector {
    bool IsTextSearchEnabled { get; set; }
    public static DependencyProperty IsTextSearchEnabledProperty { get; }
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public class CommandBar : AppBar {
    bool IsDynamicOverflowEnabled { get; set; }
    public static DependencyProperty IsDynamicOverflowEnabledProperty { get; }
    event TypedEventHandler<CommandBar, DynamicOverflowItemsChangingEventArgs> DynamicOverflowItemsChanging;
  }
  public enum CommandBarDynamicOverflowAction
  public class Control : FrameworkElement {
    ElementSoundMode ElementSoundMode { get; set; }
    public static DependencyProperty ElementSoundModeProperty { get; }
    bool IsFocusEngaged { get; set; }
    public static DependencyProperty IsFocusEngagedProperty { get; }
    bool IsFocusEngagementEnabled { get; set; }
    public static DependencyProperty IsFocusEngagementEnabledProperty { get; }
    RequiresPointer RequiresPointer { get; set; }
    event TypedEventHandler<Control, FocusDisengagedEventArgs> FocusDisengaged;
    event TypedEventHandler<Control, FocusEngagedEventArgs> FocusEngaged;
    void RemoveFocusEngagement();
  }
  public class DatePicker : Control {
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public sealed class DynamicOverflowItemsChangingEventArgs
  public sealed class FocusDisengagedEventArgs : RoutedEventArgs
  public sealed class FocusEngagedEventArgs : RoutedEventArgs
  public interface ICommandBarElement2
  public sealed class Image : FrameworkElement {
    CompositionBrush GetAlphaMask();
  }
  public class InkToolbar : Control
  public class InkToolbarBallpointPenButton : InkToolbarPenButton
  public class InkToolbarCustomPen : DependencyObject
  public class InkToolbarCustomPenButton : InkToolbarPenButton
  public class InkToolbarCustomToggleButton : InkToolbarToggleButton
  public class InkToolbarCustomToolButton : InkToolbarToolButton
  public class InkToolbarEraserButton : InkToolbarToolButton
  public class InkToolbarHighlighterButton : InkToolbarPenButton
  public enum InkToolbarInitialControls
  public class InkToolbarPenButton : InkToolbarToolButton
  public class InkToolbarPencilButton : InkToolbarPenButton
  public class InkToolbarPenConfigurationControl : Control
  public class InkToolbarRulerButton : InkToolbarToggleButton
  public enum InkToolbarToggle
  public class InkToolbarToggleButton : CheckBox
  public enum InkToolbarTool
  public class InkToolbarToolButton : RadioButton
  public enum LightDismissOverlayMode
  public class MediaPlayerElement : Control
  public class MediaPlayerPresenter : FrameworkElement
  public class MediaTransportControls : Control {
    FastPlayFallbackBehaviour FastPlayFallbackBehaviour { get; set; }
    public static DependencyProperty FastPlayFallbackBehaviourProperty { get; }
    bool IsNextTrackButtonVisible { get; set; }
    public static DependencyProperty IsNextTrackButtonVisibleProperty { get; }
    bool IsPreviousTrackButtonVisible { get; set; }
    public static DependencyProperty IsPreviousTrackButtonVisibleProperty { get; }
    bool IsSkipBackwardButtonVisible { get; set; }
    public static DependencyProperty IsSkipBackwardButtonVisibleProperty { get; }
    bool IsSkipBackwardEnabled { get; set; }
    public static DependencyProperty IsSkipBackwardEnabledProperty { get; }
    bool IsSkipForwardButtonVisible { get; set; }
    public static DependencyProperty IsSkipForwardButtonVisibleProperty { get; }
    bool IsSkipForwardEnabled { get; set; }
    public static DependencyProperty IsSkipForwardEnabledProperty { get; }
    event TypedEventHandler<MediaTransportControls, MediaTransportControlsThumbnailRequestedEventArgs> ThumbnailRequested;
  }
  public class Pivot : ItemsControl {
    PivotHeaderFocusVisualPlacement HeaderFocusVisualPlacement { get; set; }
    public static DependencyProperty HeaderFocusVisualPlacementProperty { get; }
    bool IsHeaderItemsCarouselEnabled { get; set; }
    public static DependencyProperty IsHeaderItemsCarouselEnabledProperty { get; }
  }
  public enum PivotHeaderFocusVisualPlacement
  public enum RequiresPointer
  public class SplitView : Control {
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public sealed class TextBlock : FrameworkElement {
    CompositionBrush GetAlphaMask();
  }
  public class TimePicker : Control {
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public enum WebViewPermissionType {
    WebNotifications = 4,
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class FlyoutBase : DependencyObject {
    bool AllowFocusWhenDisabled { get; set; }
    public static DependencyProperty AllowFocusWhenDisabledProperty { get; }
    ElementSoundMode ElementSoundMode { get; set; }
    public static DependencyProperty ElementSoundModeProperty { get; }
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
  public sealed class Popup : FrameworkElement {
    LightDismissOverlayMode LightDismissOverlayMode { get; set; }
    public static DependencyProperty LightDismissOverlayModeProperty { get; }
  }
}
namespace Windows.UI.Xaml.Documents {
  public sealed class Hyperlink : Span {
    ElementSoundMode ElementSoundMode { get; set; }
    public static DependencyProperty ElementSoundModeProperty { get; }
  }
  public class TextElement : DependencyObject {
    bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
    public static DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
  }
}
namespace Windows.UI.Xaml.Input {
  public enum InputScopeNameValue {
    ChatWithoutEmoji = 68,
  }
  public sealed class KeyRoutedEventArgs : RoutedEventArgs {
    string DeviceId { get; }
  }
}
namespace Windows.UI.Xaml.Media {
  public sealed class BrushCollection : IIterable<Brush>, IVector<Brush>
  public enum FastPlayFallbackBehaviour
  public sealed class MediaTransportControlsThumbnailRequestedEventArgs
}
namespace Windows.UI.Xaml.Media.Animation {
  public sealed class ConnectedAnimation
  public sealed class ConnectedAnimationService
}
namespace Windows.UI.Xaml.Shapes {
  public class Shape : FrameworkElement {
    CompositionBrush GetAlphaMask();
  }
}
namespace Windows.Media.Capture {
  public sealed class AppCaptureSettings {
    AppCaptureVideoEncodingFrameRateMode VideoEncodingFrameRateMode { get; set; }
  }
  public enum AppCaptureVideoEncodingFrameRateMode
}
namespace Windows.Networking.Sockets {
  public sealed class ControlChannelTrigger : IClosable {
    bool IsWakeFromLowPowerSupported { get; }
  }
}

Removed APIs

namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactList {
    ContactListConstraints Constraints { get; }
  }
  public sealed class ContactListConstraints
}
namespace Windows.ApplicationModel.Store {
  public sealed class PackageUpdate
  public static class PackageUpdateManager
  public sealed class PackageUpdateResult
  public enum PackageUpdateState
  public struct PackageUpdateStatus
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallManager {
    IAsyncOperation<AppInstallItem> StartAppInstallAsync(string productId, string skuId, bool repair, bool forceUseOfNonRemovableStorage, string catalogId, string bundleId, string correlationVector, PackageVolume targetVolume);
  }
}
namespace Windows.ApplicationModel.UserDataAccounts.SystemAccess {
  public static class UserDataAccountSystemAccessManager {
    public static IAsyncAction MakeDefaultAccountAsync(string userDataAccountId);
  }
}
namespace Windows.Media.Audio {
  public sealed class AudioDeviceOutputNode : IAudioNode, IAudioNode2, IClosable {
  }
  public sealed class AudioFileOutputNode : IAudioNode, IAudioNode2, IClosable {
    AudioNodeListener Listener { get; set; }
  }
  public sealed class AudioFrameOutputNode : IAudioNode, IAudioNode2, IClosable {
    AudioNodeListener Listener { get; set; }
  }
  public sealed class AudioNodeEmitter {
    bool IsDopplerDisabled { get; }
  }
  public interface IAudioNode2 : IAudioNode, IClosable
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor {
    IReference<uint> EncoderDelay { get; set; }
    IReference<uint> EncoderPadding { get; set; }
  }
  public sealed class MediaStreamSource : IMediaSource {
    event TypedEventHandler<MediaStreamSource, MediaStreamSourceSampleLagOccuredEventArgs> SampleLagOccured;
  }
  public sealed class MediaStreamSourceSampleLag
  public sealed class MediaStreamSourceSampleLagOccuredEventArgs
}
namespace Windows.Media.MediaProperties {
  public enum StereoVideoPackingMode
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    StereoVideoPackingMode StereoVideoPackingMode { get; }
  }
}
namespace Windows.Media.Playback {
  public sealed class AutoRepeatModeCommandReceivedEventArgs
  public sealed class FastForwardCommandReceivedEventArgs
  public enum FrameStepDirection
  public sealed class MediaBreakManager {
    MediaPlaybackSession PlaybackSession { get; }
  }
  public enum MediaCommandEnablingRule
  public sealed class MediaItemDisplayProperties {
    RandomAccessStreamReference BackgroundArt { get; set; }
    void ApplyChanges();
  }
  public sealed class MediaPlaybackCommandManager {
    PlaybackCommandEnabledBehavior AutoRepeatModeEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior FastForwardEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior NextEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior PauseEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior PlaybackPositionEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior PlaybackRateEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior PlayEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior PreviousEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior RewindEnabledBehavior { get; set; }
    PlaybackCommandEnabledBehavior ShuffleEnabledBehavior { get; set; }
    event TypedEventHandler<MediaPlaybackCommandManager, AutoRepeatModeCommandReceivedEventArgs> AutoRepeatModeCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, FastForwardCommandReceivedEventArgs> FastForwardCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, NextCommandReceivedEventArgs> NextCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, PauseCommandReceivedEventArgs> PauseCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, PlaybackPositionCommandReceivedEventArgs> PlaybackPositionCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, PlaybackRateCommandReceivedEventArgs> PlaybackRateCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, PlayCommandReceivedEventArgs> PlayCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, PreviousCommandReceivedEventArgs> PreviousCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, RewindCommandReceivedEventArgs> RewindCommandReceived;
    event TypedEventHandler<MediaPlaybackCommandManager, ShuffleCommandReceivedEventArgs> ShuffleCommandReceived;
  }
  public sealed class MediaPlaybackItem : IMediaPlaybackSource {
    MediaItemDisplayProperties DisplayProperties { get; }
  }
  public sealed class MediaPlayer : IClosable {
    double Balance { get; set; }
    double DownloadProgress { get; }
    int NaturalVideoHeight { get; }
    int NaturalVideoWidth { get; }
    NormalizedRect PanAndZoomRect { get; set; }
    StereoVideoPackingMode StereoVideoPackingMode { get; set; }
    StereoVideoRenderMode StereoVideoRenderMode { get; set; }
    event TypedEventHandler<MediaPlayer, object> BufferingProgressChanged;
    event TypedEventHandler<MediaPlayer, object> DownloadProgressChanged;
    event TypedEventHandler<MediaPlayer, object> MutingChanged;
    event TypedEventHandler<MediaPlayer, object> NaturalDurationChanged;
    event TypedEventHandler<MediaPlayer, object> NaturalVideoSizeChanged;
    event TypedEventHandler<MediaPlayer, object> PositionChanged;
    void AddVideoEffect(string effectID, bool effectOptional, IPropertySet effectConfiguration);
    void FrameStep(FrameStepDirection value);
    MediaPlayerPlaybackStatistics GetPlaybackStatistics();
  }
  public sealed class MediaPlayerPlaybackStatistics
  public sealed class NextCommandReceivedEventArgs
  public struct NormalizedRect
  public sealed class PauseCommandReceivedEventArgs
  public enum PlaybackCommandEnabledBehavior
  public sealed class PlaybackPositionCommandReceivedEventArgs
  public sealed class PlaybackRateCommandReceivedEventArgs
  public sealed class PlayCommandReceivedEventArgs
  public sealed class PreviousCommandReceivedEventArgs
  public sealed class RewindCommandReceivedEventArgs
  public sealed class ShuffleCommandReceivedEventArgs
  public enum StereoVideoRenderMode
}
namespace Windows.Media.Protection {
  public enum HdcpLevel
  public enum HdcpLevelAsyncResultStatus
  public sealed class HdcpSettingResult
  public sealed class HdcpState
}
namespace Windows.Security.Authentication.Identity.Core {
  public sealed class MicrosoftAccountMultiFactorAuthenticationManager {
    IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(string userAccountId, string sessionId, MicrosoftAccountMultiFactorAuthenticationType sessionAuthenticationType, MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus);
    IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(MicrosoftAccountMultiFactorSessionInfo authenticationSessionInfo, MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus);
  }
}
namespace Windows.System.Profile {
  public static class DeviceIdentification
}
namespace Windows.UI.Composition {
  public sealed class AnimationGroup : CompositionObject, IImplicitAnimationMapEntry, IIterable<IKeyValuePair<string, CompositionAnimation>>, IMap<string, CompositionAnimation>
  public sealed class CompositionDestinationBrush : CompositionBrush
  public class CompositionInteractionSource : CompositionObject, ICompositionInteractionSource
  public sealed class CompositionInteractionSourceCollection : CompositionObject, IIterable<ICompositionInteractionSource>
  public class CompositionObject : IClosable {
    ImplicitAnimationMap ImplicitAnimations { get; set; }
  }
  public sealed class CompositionPropertyChangedEventArgs : CompositionObject
  public sealed class Compositor : IClosable {
    AnimationGroup CreateAnimationGroup();
    CompositionDestinationBrush CreateDestinationBrush();
    ImplicitAnimationMap CreateImplicitAnimationMap();
    InteractionTracker CreateInteractionTracker();
    InteractionTrackerInertiaEndpoint CreateInteractionTrackerInertiaEndpoint();
    InteractionTrackerInertiaMotion CreateInteractionTrackerInertiaMotion();
  }
  public interface ICompositionInteractionSource
  public interface IImplicitAnimationMapEntry
  public interface IInteractionTrackerInertiaEndpoint
  public interface IInteractionTrackerInertiaModifier
  public interface IInteractionTrackerInertiaMotion
  public interface IInteractionTrackerOwner
  public sealed class ImplicitAnimationMap : CompositionObject, IIterable<IKeyValuePair<string, IImplicitAnimationMapEntry>>, IMap<string, IImplicitAnimationMapEntry>
  public enum InteractionNestingMode
  public enum InteractionSourceMode
  public enum InteractionSystemManipulationMode
  public sealed class InteractionTracker : CompositionObject
  public sealed class InteractionTrackerCustomAnimationStateEnteredArgs : CompositionObject
  public sealed class InteractionTrackerIdleStateEnteredArgs : CompositionObject
  public sealed class InteractionTrackerInContactStateEnteredArgs : CompositionObject
  public sealed class InteractionTrackerInertiaEndpoint : InteractionTrackerInertiaModifier, IInteractionTrackerInertiaEndpoint
  public class InteractionTrackerInertiaModifier : IInteractionTrackerInertiaModifier
  public sealed class InteractionTrackerInertiaMotion : InteractionTrackerInertiaModifier, IInteractionTrackerInertiaMotion
  public sealed class InteractionTrackerInertiaStateEnteredArgs : CompositionObject
  public sealed class InteractionTrackerRequestIgnoredArgs : CompositionObject
  public sealed class InteractionTrackerValuesChangedArgs : CompositionObject
  public class KeyFrameAnimation : CompositionAnimation, IImplicitAnimationMapEntry {
  }
  public sealed class StepEasingFunction : CompositionEasingFunction {
    int FinishAtStep { get; set; }
    bool InstantFinish { get; set; }
    bool InstantStart { get; set; }
    int StartAtStep { get; set; }
  }
  public class Visual : CompositionObject {
    float RelativeHeight { get; set; }
    float RelativeOffsetX { get; set; }
    float RelativeOffsetY { get; set; }
    float RelativeWidth { get; set; }
    bool SnapToPixels { get; set; }
  }
  public sealed class VisualInteractionSource : CompositionInteractionSource, ICompositionInteractionSource
}
namespace Windows.UI.Xaml.Controls {
  public class Control : FrameworkElement {
    RequiresPointerMode RequiresPointer { get; set; }
  }
  public class Pivot : ItemsControl {
    PivotHeaderOverflowMode HeaderOverflowMode { get; set; }
    public static DependencyProperty HeaderOverflowModeProperty { get; }
  }
  public enum PivotHeaderOverflowMode
  public enum RequiresPointerMode
}
namespace Windows.Media.Capture {
  public enum AppCaptureCameraOverlayLocation
  public enum AppCaptureCameraOverlaySize
  public sealed class AppCaptureSettings {
    AppCaptureCameraOverlayLocation CameraOverlayLocation { get; set; }
    AppCaptureCameraOverlaySize CameraOverlaySize { get; set; }
    bool IsCameraCaptureEnabledByDefault { get; set; }
    bool IsEchoCancellationEnabled { get; set; }
    string SelectedCameraId { get; set; }
  }
}

Windows 10 SDK Preview Build 14267 Released

Today, we released a new Windows 10 SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14267 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14267 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview. This is a pre-release of the Windows 10 SDK. This release should only be installed on test machines, and is not supported in a production environment.  The APIs and software included in this preview should not be expected to be final and may not be included in the commercial version.

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 feature requests, head over to our Windows Platform UserVoice.

What’s New

This Windows SDK includes the following updates and additions to the Windows namespace since Windows SDK 10586.

  • Windows.Gaming.Input.Custom
    • Enables hardware vendors to create runtime class libraries that provide rich access to their game controllers’ functionality.
  • Windows.UI.Composition
    • MinBlend looks at source and destination pixel and chooses the minimum of the two.
    • The 3×2 transform added to CompositionSurfaceBrush enables a transform to be applied to a brush before it is used to paint the visual.
  • Windows.Web.Http.HttpClient
    • Windows.Web.Http.HttpClient API now allows you to explicitly turn off reading HTTP responses from cache and ensure that your request goes on the network.
  • Debugging tools for Windows (Windbg, kd, cdb, ntsd) now have improved support for universal app debugging. This update also requires the Universal C Runtime Library (uCRT), which is available via Windows Update. KB and MSDN documentation will be available within a few weeks.

Known Issues

  • Emulator
    • There is no Windows 10 Mobile Emulator available for Preview SDK Build 14267.
  • Installation Errors
    • This SDK should not be installed on any production level operating systems.  Installing on a production level OS may result in a failure to install the SDK.
  • Cannot submit apps to the store
    • This SDK will update your SDK tools and Windows App Certification Kit required for creating apps.  Apps built with these tools will be prevented from submitting to the store.  To restore your machine, you will need to uninstall all previous Windows SDKs and need to repair your Visual Studio installation.
  • If the SDK fails to install and presents the following error, “Windows Phone IP over USB Transport (IpOverUsbSvc)’ (IpOverUsbSvc) failed to start.  Verify that you have sufficient privileges to start system services.”  Then make sure you are installing the SDK on a build of Windows 10 build 14267 or greater and that machine is configured to be a Windows Insider.

API Updates and Additions

namespace Windows.Gaming.Input.Custom {
  public static class GameControllerFactoryManager
  public struct GameControllerVersionInfo
  public struct GipFirmwareUpdateProgress
  public sealed class GipFirmwareUpdateResult
  public enum GipFirmwareUpdateStatus
  public sealed class GipGameControllerProvider : IGameControllerProvider
  public enum GipMessageClass
  public interface ICustomGameControllerFactory
  public interface IGameControllerInputSink
  public interface IGameControllerProvider
  public interface IGipGameControllerInputSink : IGameControllerInputSink
  public interface IXusbGameControllerInputSink : IGameControllerInputSink
  public enum XusbDeviceSubtype
  public enum XusbDeviceType
  public sealed class XusbGameControllerProvider : IGameControllerProvider
}
 
namespace Windows.UI.Composition {
  public sealed class AnimationClass : CompositionObject
  public sealed class AnimationGroup : CompositionObject, IIterable<KeyFrameAnimation>
  public enum CompositionCompositeMode {
    MinBlend = 3,
  }
  public enum CompositionGradientWrapMode
  public sealed class CompositionLinearGradientBrush : CompositionBrush
  public sealed class CompositionMaskBrush : CompositionBrush
  public sealed class CompositionSurfaceBrush : CompositionBrush {
    Matrix3x2 Transform { get; set; }
  }
  public sealed class Compositor : IClosable {
    AnimationClass CreateAnimationClass();
    AnimationGroup CreateAnimationGroup();
    ConditionalExpressionAnimation CreateConditionalExpressionAnimation();
    ConditionalExpressionAnimation CreateConditionalExpressionAnimation(ConditionalExpressionAnimationSelection selection);
    CompositionMaskBrush CreateMaskBrush();
    ScrollTracker CreateScrollTracker();
  }
  public sealed class ConditionalExpressionAnimation : CompositionAnimation
  public enum ConditionalExpressionAnimationSelection
  public sealed class ScrollTracker : CompositionObject
  public class Visual : CompositionObject {
    AnimationClass AnimationClass { get; set; }
    float RelativeHeight { get; set; }
    float RelativeOffsetX { get; set; }
    float RelativeOffsetY { get; set; }
    float RelativeWidth { get; set; }
    bool SnapToPixels { get; set; }
  }
  public enum VisualEvents : uint
}
 
namespace Windows.Web.Http.Filters {
  public enum HttpCacheReadBehavior {
    NoCache = 3,
  }
}

The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. If you are working on an application that you need to submit to the store, you should not install the preview. This is a pre-release of the Windows 10 SDK. The APIs and software included in this preview should not be expected to be final and may not be included in the commercial version.