Windows 10 SDK Preview Build 15021 Released

Windows 10 SDK Preview Build 15021 Released

Today, we released a new Windows 10 Creators Update SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 15021 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 15021 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:

• The SDK will require Visual Studio 2017 Preview. You can download the Visual Studio 2017 Preview.

What’s New

• This Windows SDK includes updates and additions to the Windows namespace. See section API Updates and Additions below for the list of differences since the Windows 10 Anniversary Update (Build 10586)
• Debugging Tools for Windows has been updated with a few new features, including JavaScript scripting and extensibility. See the blogpost at https://blogs.msdn.microsoft.com/windbg/2016/10/27/new-insider-sdk-and-javascript-extensibility/ for more information.

Known Issues Windows SDK

• There are no known issues with the SDK and emulator

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,
    PrintWorkflowForegroundTask = 1018,
  }
  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 ShareProvider
  public delegate void ShareProviderHandler(ShareProviderOperation operation);
  public sealed class ShareProviderOperation
  public sealed class ShareProvidersRequestedEventArgs
  public sealed class ShareTargetInfo
}
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 AppInstallItem {
    IVectorView<AppInstallItem> Children { get; }
    bool ItemOperationsMightAffectOtherItems { get; }
  }
  public sealed class AppInstallManager {
    IVectorView<AppInstallItem> AppInstallItemsWithGroupSupport { get; }
    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(Guid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(Guid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
  }
  public static class BluetoothUuidHelper
}
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(Guid descriptorUuid);
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(Guid 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 {
    AccessDenied = 3,
    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(Guid characteristicUuid);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(Guid characteristicUuid, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndUuid(BluetoothDeviceId bluetoothDeviceId, Guid serviceUuid);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndUuid(BluetoothDeviceId bluetoothDeviceId, Guid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync();
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(Guid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(Guid 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 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 GattWriteRequest
  public sealed class GattWriteRequestedEventArgs
  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 {
  public sealed class BrightnessOverride
  public enum DisplayBrightnessOverrideOptions : uint
  public enum DisplayBrightnessScenario
}
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.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 NamedPolicy
  public sealed class NamedPolicyData
  public enum NamedPolicyKind
}
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;
    IAsyncOperation<MultiSourceMediaFrameReader> CreateMultiSourceFrameReaderAsync(IIterable<MediaFrameSource> inputSources);
  }
  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,
  }
  public sealed class MediaFrameSourceController {
    IAsyncOperation<MediaFrameSourceGetPropertyResult> GetPropertyByExtendedIdAsync(byte[] extendedPropertyId, IReference<uint> maxPropertyValueSize);
    IAsyncOperation<MediaFrameSourceSetPropertyStatus> SetPropertyByExtendedIdAsync(byte[] extendedPropertyId, byte[] propertyValue);
  }
  public enum MediaFrameSourceGetPropertyStatus {
    MaxPropertyValueSizeRequired = 5,
    MaxPropertyValueSizeTooSmall = 4,
  }
  public sealed class MultiSourceMediaFrameArrivedEventArgs
  public sealed class MultiSourceMediaFrameReader : IClosable
  public enum MultiSourceMediaFrameReaderStartStatus
  public sealed class MultiSourceMediaFrameReference : IClosable
}
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; }
    VideoDeviceControllerGetDevicePropertyResult GetDevicePropertyByExtendedId(byte[] extendedPropertyId, IReference<uint> maxPropertyValueSize);
    VideoDeviceControllerGetDevicePropertyResult GetDevicePropertyById(string propertyId, IReference<uint> maxPropertyValueSize);
    VideoDeviceControllerSetDevicePropertyStatus SetDevicePropertyByExtendedId(byte[] extendedPropertyId, byte[] propertyValue);
    VideoDeviceControllerSetDevicePropertyStatus SetDevicePropertyById(string propertyId, object propertyValue);
  }
  public sealed class VideoDeviceControllerGetDevicePropertyResult
  public enum VideoDeviceControllerGetDevicePropertyStatus
  public enum VideoDeviceControllerSetDevicePropertyStatus
}
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 interface IWebAccountProviderTokenObjects2 : IWebAccountProviderTokenObjects
  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, IWebAccountProviderTokenObjects2 {
    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.Telemetry {
  public static class PlatformTelemetryClient
  public sealed class PlatformTelemetryRegistrationResult
  public sealed class PlatformTelemetryRegistrationSettings
  public enum PlatformTelemetryRegistrationStatus
}
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.System.UserProfile {
  public sealed class FeedbackAndDiagnosticsSettings
}
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 class KeyFrameAnimation : CompositionAnimation {
    AnimationDelayBehavior DelayBehavior { get; set; }
  }
  public class Visual : CompositionObject {
    Visual ParentForTransform { get; set; }
    Vector3 RelativeOffsetAdjustment { get; set; }
    Vector2 RelativeSizeAdjustment { get; set; }
  }
}
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 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
  public sealed class WebUIPrintWorkflowForegroundTaskActivatedEventArgs : 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 {
  }
}

Source: Windows 10 SDK Preview Build 15021 Released