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.