February 3, 2017 2:03 pm

Windows 10 SDK Preview Build 15021 Released

By / Senior Technical Product Manager, Windows Developer Team

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:

What’s New

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.

[code lang=”csharp”]

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);
}
}

[/code]

API Removals

[code lang=”csharp”]
namespace Windows.UI.Composition {
public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
}
}
namespace Windows.UI.Composition.Interactions {
public sealed class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
}
}

[/code]