Windows 10 16215 vs. 16193 WinRT API Changes

 MetaDiff v0.1 https://github.com/WalkingCat/MetaDiff

 new files: 16215\Windows\System32\WinMetadata\*.winmd
 old files: 16193\Windows\System32\WinMetadata\*.winmd

 diff legends: +: added, -: removed, *: changed, |: type member changed

| public class Windows.ApplicationModel.DesignMode {
+   public bool DesignMode2Enabled { get; }
| }

| public enum Windows.ApplicationModel.StartupTaskState {
+   DisabledByPolicy = 3,
| }

| public enum Windows.ApplicationModel.Activation.ActivationKind {
+   GameUIProvider = 1019,
+   StartupTask = 1020,
+   CommandLineLaunch = 1021,
-   Console = 1019,
| }

+ public class Windows.ApplicationModel.Activation.CommandLineActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public User User { get; }
+   public CommandLineActivationOperation Operation { get; }
+ }

+ public class Windows.ApplicationModel.Activation.CommandLineActivationOperation {
+   public int ExitCode { get; set; }
+   public string Arguments { get; }
+   public string CurrentDirectoryPath { get; }
+   public Deferral GetDeferral();
+ }

- public class Windows.ApplicationModel.Activation.ConsoleActivatedEventArgs;

+ public interface Windows.ApplicationModel.Activation.ICommandLineActivatedEventArgs {
+   public CommandLineActivationOperation Operation { get; }
+ }

- public interface Windows.ApplicationModel.Activation.IConsoleActivatedEventArgs;

+ public interface Windows.ApplicationModel.Activation.IStartupTaskActivatedEventArgs {
+   public string TaskId { get; }
+ }

+ public class Windows.ApplicationModel.Activation.StartupTaskActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public User User { get; }
+   public string TaskId { get; }
+ }

- public enum Windows.ApplicationModel.AppService.AppServiceCallerCapabilityStatus;

| public class Windows.ApplicationModel.AppService.AppServiceTriggerDetails {
+   public IAsyncOperation<bool> CheckCallerForCapabilityAsync( string operation );
-   public IAsyncOperation<AppServiceCallerCapabilityStatus> GetCallerCapabilityStatusAsync( string operation );
| }

| public class Windows.ApplicationModel.Appointments.AppointmentStore {
+   public AppointmentStoreChangeTracker GetChangeTracker( string result );
| }

| public class Windows.ApplicationModel.Appointments.AppointmentStoreChangeTracker {
+   public bool IsTracking { get; }
| }

+ public class Windows.ApplicationModel.Background.PaymentAppCanMakePaymentTrigger {
+   public PaymentAppCanMakePaymentTrigger();
+ }

+ public class Windows.ApplicationModel.Background.SmartCardTrigger {
+   public SmartCardTriggerType TriggerType { get; }
+   public SmartCardTrigger( SmartCardTriggerType triggerType );
+ }

| public class Windows.ApplicationModel.Calls.VoipCallCoordinator {
+   public VoipPhoneCall SetupNewAcceptedCall( string call, string context, string contactName, string contactNumber, VoipPhoneCallMedia serviceName );
| }

| public class Windows.ApplicationModel.Calls.VoipPhoneCall {
+   public void TryShowAppUI();
| }

- public class Windows.ApplicationModel.Cards.CardBuilder;

- public interface Windows.ApplicationModel.Cards.ICardBuilderStatics;

- public interface Windows.ApplicationModel.Cards.ICardElement;

| public class Windows.ApplicationModel.Contacts.ContactChangeTracker {
+   public bool IsTracking { get; }
| }

| public class Windows.ApplicationModel.Contacts.ContactList {
+   public ContactChangeTracker GetChangeTracker( string result );
| }

| public class Windows.ApplicationModel.Contacts.ContactStore {
+   public ContactChangeTracker GetChangeTracker( string result );
| }

| public class Windows.ApplicationModel.Core.AppListEntry {
+   public string AppUserModelId { get; }
| }

+ public enum Windows.ApplicationModel.Core.AppRestartFailureReason {
+   RestartPending = 0,
+   NotInForeground = 1,
+   InvalidUser = 2,
+   Other = 3,
+ }

| public class Windows.ApplicationModel.Core.CoreApplication {
+   public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync( string operation );
+   public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync( User operation, string user );
| }

- public enum Windows.ApplicationModel.Core.RestartResult;

| public class Windows.ApplicationModel.DataTransfer.DataTransferManager {
+   public static void ShowShareUI( ShareUIOptions options );
| }

| internal interface Windows.ApplicationModel.DataTransfer.IDataTransferManagerStatics3 {
+   public void ShowShareUI( ShareUIOptions options );
| }

| public class Windows.ApplicationModel.DataTransfer.ShareUIOptions {
+   public ShareUITheme Theme { get; set; }
+   public IReference<Rect> SelectionRect { get; set; }
-   public ShareUITheme ShareTheme { get; set; }
-   public IReference<Rect> InvocationRect { get; set; }
| }

| public class Windows.ApplicationModel.Email.EmailMailbox {
+   public EmailMailboxChangeTracker GetChangeTracker( string result );
| }

+ public class Windows.ApplicationModel.Payments.PaymentCanMakePaymentResult {
+   public PaymentCanMakePaymentResultStatus Status { get; }
+   public PaymentCanMakePaymentResult( PaymentCanMakePaymentResultStatus value );
+ }

+ public enum Windows.ApplicationModel.Payments.PaymentCanMakePaymentResultStatus {
+   Unknown = 0,
+   Yes = 1,
+   No = 2,
+   NotAllowed = 3,
+   UserNotSignedIn = 4,
+   SpecifiedPaymentMethodIdsNotSupported = 5,
+   NoQualifyingCardOnFile = 6,
+ }

| public class Windows.ApplicationModel.Payments.PaymentMediator {
+   public IAsyncOperation<PaymentCanMakePaymentResult> CanMakePaymentAsync( PaymentRequest result );
| }

| public class Windows.ApplicationModel.Payments.PaymentRequest {
+   public string Id { get; }
+   public PaymentRequest( PaymentDetails details, IIterable<PaymentMethodData> methodData, PaymentMerchantInfo merchantInfo, PaymentOptions options, string id );
| }

+ public class Windows.ApplicationModel.Payments.Provider.PaymentAppCanMakePaymentTriggerDetails {
+   public PaymentRequest Request { get; }
+   public void ReportCanMakePaymentResult( PaymentCanMakePaymentResult value );
+ }

+ public interface Windows.ApplicationModel.UserActivities.IUserActivityContentInfo {
+   public string ToJson();
+ }

| public class Windows.ApplicationModel.UserActivities.UserActivity {
+   public IUserActivityContentInfo ContentInfo { get; set; }
-   public string ContentMetadata { get; set; }
| }

+ public class Windows.ApplicationModel.UserActivities.UserActivityAttribution {
+   public Uri IconUri { get; set; }
+   public string AlternateText { get; set; }
+   public bool AddImageQuery { get; set; }
+   public UserActivityAttribution( Uri iconUri );
+   public UserActivityAttribution();
+ }

| public class Windows.ApplicationModel.UserActivities.UserActivityChannel {
+   public IAsyncAction DeleteActivityAsync( string operation );
+   public IAsyncAction DeleteAllActivitiesAsync();
| }

+ public class Windows.ApplicationModel.UserActivities.UserActivityContentInfo {
+   public string ToJson();
+   public static UserActivityContentInfo FromJson( string result );
+ }

| public class Windows.ApplicationModel.UserActivities.UserActivityVisualElements {
*   public IAdaptiveCard Content { get; set; }
+   public UserActivityAttribution Attribution { get; set; }
-   public Uri ImageIcon { get; set; }
| }

| public class Windows.ApplicationModel.UserActivities.Core.CoreUserActivityManager {
+   public static IAsyncAction DeleteUserActivitySessionsInTimeRangeAsync( UserActivityChannel operation, DateTime channel, DateTime startTime );
| }

| public class Windows.Devices.PointOfService.ClaimedLineDisplay {
+   public LineDisplayCustomGlyphs CustomGlyphs { get; }
+   public Size MaxBitmapSizeInPixels { get; }
+   public IVectorView<int> SupportedCharacterSets { get; }
+   public IVectorView<Size> SupportedScreenSizesInCharacters { get; }
+   public IAsyncOperation<string> GetStatisticsAsync( IIterable<string> result );
+   public IAsyncOperation<string> CheckHealthAsync( UnifiedPosHealthCheckLevel result );
+   public IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
+   public LineDisplayAttributes GetAttributes();
+   public IAsyncOperation<bool> TryUpdateAttributesAsync( LineDisplayAttributes operation );
+   public IAsyncOperation<bool> TrySetDescriptorAsync( uint operation, LineDisplayDescriptorState descriptor );
+   public IAsyncOperation<bool> TryClearDescriptorsAsync();
+   public IAsyncOperation<LineDisplayWindow> TryCreateWindowAsync( Rect result, Size viewport );
+   public IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync( StorageFile result );
+   public IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync( StorageFile result, LineDisplayHorizontalAlignment bitmap, LineDisplayVerticalAlignment horizontalAlignment );
+   public IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync( StorageFile result, LineDisplayHorizontalAlignment bitmap, LineDisplayVerticalAlignment horizontalAlignment, int verticalAlignment );
| }

| public class Windows.Devices.PointOfService.LineDisplay {
+   public LineDisplayStatisticsCategorySelector StatisticsCategorySelector { get; }
+   public IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
| }

+ public class Windows.Devices.PointOfService.LineDisplayAttributes {
+   public Size ScreenSizeInCharacters { get; set; }
+   public bool IsPowerNotifyEnabled { get; set; }
+   public bool IsCharacterSetMappingEnabled { get; set; }
+   public LineDisplayWindow CurrentWindow { get; set; }
+   public int CharacterSet { get; set; }
+   public int Brightness { get; set; }
+   public TimeSpan BlinkRate { get; set; }
+ }

+ public class Windows.Devices.PointOfService.LineDisplayCursor {
+   public bool CanCustomize { get; }
+   public bool IsBlinkSupported { get; }
+   public bool IsBlockSupported { get; }
+   public bool IsHalfBlockSupported { get; }
+   public bool IsOtherSupported { get; }
+   public bool IsReverseSupported { get; }
+   public bool IsUnderlineSupported { get; }
+   public LineDisplayCursorAttributes GetAttributes();
+   public IAsyncOperation<bool> TryUpdateAttributesAsync( LineDisplayCursorAttributes operation );
+ }

+ public class Windows.Devices.PointOfService.LineDisplayCursorAttributes {
+   public Point Position { get; set; }
+   public bool IsBlinkEnabled { get; set; }
+   public bool IsAutoAdvanceEnabled { get; set; }
+   public LineDisplayCursorType CursorType { get; set; }
+ }

+ public enum Windows.Devices.PointOfService.LineDisplayCursorType {
+   None = 0,
+   Block = 1,
+   HalfBlock = 2,
+   Underline = 3,
+   Reverse = 4,
+   Other = 5,
+ }

+ public class Windows.Devices.PointOfService.LineDisplayCustomGlyphs {
+   public Size SizeInPixels { get; }
+   public IVectorView<uint> SupportedGlyphCodes { get; }
+   public IAsyncOperation<bool> TryRedefineAsync( uint operation, IBuffer glyphCode );
+ }

+ public enum Windows.Devices.PointOfService.LineDisplayDescriptorState {
+   Off = 0,
+   On = 1,
+   Blink = 2,
+ }

+ public enum Windows.Devices.PointOfService.LineDisplayHorizontalAlignment {
+   Left = 0,
+   Center = 1,
+   Right = 2,
+ }

+ public class Windows.Devices.PointOfService.LineDisplayMarquee {
+   public TimeSpan ScrollWaitInterval { get; set; }
+   public TimeSpan RepeatWaitInterval { get; set; }
+   public LineDisplayMarqueeFormat Format { get; set; }
+   public IAsyncOperation<bool> TryStartScrollingAsync( LineDisplayScrollDirection operation );
+   public IAsyncOperation<bool> TryStopScrollingAsync();
+ }

+ public enum Windows.Devices.PointOfService.LineDisplayMarqueeFormat {
+   None = 0,
+   Walk = 1,
+   Place = 2,
+ }

+ public enum Windows.Devices.PointOfService.LineDisplayPowerStatus {
+   Unknown = 0,
+   Online = 1,
+   Off = 2,
+   Offline = 3,
+   OffOrOffline = 4,
+ }

+ public class Windows.Devices.PointOfService.LineDisplayStatisticsCategorySelector {
+   public string AllStatistics { get; }
+   public string ManufacturerStatistics { get; }
+   public string UnifiedPosStatistics { get; }
+ }

+ public class Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs {
+   public LineDisplayPowerStatus Status { get; }
+ }

+ public class Windows.Devices.PointOfService.LineDisplayStoredBitmap {
+   public string EscapeSequence { get; }
+   public IAsyncOperation<bool> TryDeleteAsync();
+ }

+ public enum Windows.Devices.PointOfService.LineDisplayVerticalAlignment {
+   Top = 0,
+   Center = 1,
+   Bottom = 2,
+ }

| public class Windows.Devices.PointOfService.LineDisplayWindow {
+   public LineDisplayCursor Cursor { get; }
+   public LineDisplayMarquee Marquee { get; }
+   public IAsyncOperation<uint> ReadCharacterAtCursorAsync();
+   public IAsyncOperation<bool> TryDisplayStoredBitmapAtCursorAsync( LineDisplayStoredBitmap operation );
+   public IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync( StorageFile operation );
+   public IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync( StorageFile operation, LineDisplayHorizontalAlignment bitmap, LineDisplayVerticalAlignment horizontalAlignment );
+   public IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync( StorageFile operation, LineDisplayHorizontalAlignment bitmap, LineDisplayVerticalAlignment horizontalAlignment, int verticalAlignment );
+   public IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync( StorageFile operation, Point bitmap );
+   public IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync( StorageFile operation, Point bitmap, int offsetInPixels );
| }

| public class Windows.Devices.Sensors.Accelerometer {
+   public static IAsyncOperation<Accelerometer> FromIdAsync( string operation );
+   public static string GetDeviceSelector( AccelerometerReadingType result );
| }

| public class Windows.Devices.Sensors.AccelerometerReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.Altimeter {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
| }

| public class Windows.Devices.Sensors.AltimeterReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.Barometer {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
+   public static IAsyncOperation<Barometer> FromIdAsync( string operation );
+   public static string GetDeviceSelector();
| }

| public class Windows.Devices.Sensors.BarometerReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.Compass {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
+   public static string GetDeviceSelector();
+   public static IAsyncOperation<Compass> FromIdAsync( string operation );
| }

| public class Windows.Devices.Sensors.CompassReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.Gyrometer {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
+   public static string GetDeviceSelector();
+   public static IAsyncOperation<Gyrometer> FromIdAsync( string operation );
| }

| public class Windows.Devices.Sensors.GyrometerReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.Inclinometer {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
+   public static string GetDeviceSelector( SensorReadingType result );
+   public static IAsyncOperation<Inclinometer> FromIdAsync( string operation );
| }

| public class Windows.Devices.Sensors.InclinometerReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.LightSensor {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
+   public static string GetDeviceSelector();
+   public static IAsyncOperation<LightSensor> FromIdAsync( string operation );
| }

| public class Windows.Devices.Sensors.LightSensorReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.Magnetometer {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
+   public static string GetDeviceSelector();
+   public static IAsyncOperation<Magnetometer> FromIdAsync( string operation );
| }

| public class Windows.Devices.Sensors.MagnetometerReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.OrientationSensor {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
+   public static string GetDeviceSelector( SensorReadingType result );
+   public static string GetDeviceSelector( SensorReadingType result, SensorOptimizationGoal readingType );
+   public static IAsyncOperation<OrientationSensor> FromIdAsync( string operation );
| }

| public class Windows.Devices.Sensors.OrientationSensorReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
+   public IMapView<string, object> Properties { get; }
| }

| public class Windows.Devices.Sensors.Custom.CustomSensor {
+   public uint ReportLatency { get; set; }
+   public uint MaxBatchSize { get; }
| }

| public class Windows.Devices.Sensors.Custom.CustomSensorReading {
+   public IReference<TimeSpan> PerformanceCount { get; }
| }

+ public enum Windows.Devices.SmartCards.SmartCardActivationPolicyChangeResult {
+   Denied = 0,
+   Allowed = 1,
+ }

+ public class Windows.Devices.SmartCards.SmartCardAppletIdGroup {
+   public SmartCardEmulationType SmartCardEmulationType { get; set; }
+   public SmartCardEmulationCategory SmartCardEmulationCategory { get; set; }
+   public string DisplayName { get; set; }
+   public bool AutomaticEnablement { get; set; }
+   public IVector<IBuffer> AppletIds { get; }
+   public ushort MaxAppletIds { get; }
+   public SmartCardAppletIdGroup( string displayName, IVector<IBuffer> appletIds, SmartCardEmulationCategory emulationCategory, SmartCardEmulationType emulationType );
+   public SmartCardAppletIdGroup();
+ }

+ public enum Windows.Devices.SmartCards.SmartCardAppletIdGroupActivationPolicy {
+   Disabled = 0,
+   ForegroundOverride = 1,
+   Enabled = 2,
+ }

+ public class Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration {
+   public SmartCardAppletIdGroupActivationPolicy ActivationPolicy { get; }
+   public SmartCardAppletIdGroup AppletIdGroup { get; }
+   public Guid Id { get; }
+   public IAsyncOperation<SmartCardActivationPolicyChangeResult> RequestActivationPolicyChangeAsync( SmartCardAppletIdGroupActivationPolicy result );
+   public IAsyncAction SetAutomaticResponseApdusAsync( IIterable<SmartCardAutomaticResponseApdu> result );
+ }

+ public class Windows.Devices.SmartCards.SmartCardAutomaticResponseApdu {
+   public bool ShouldMatchLength { get; set; }
+   public IBuffer ResponseApdu { get; set; }
+   public IBuffer CommandApduBitMask { get; set; }
+   public IBuffer CommandApdu { get; set; }
+   public IBuffer AppletId { get; set; }
+   public IReference<uint> OutputState { get; set; }
+   public IReference<uint> InputState { get; set; }
+   public bool AllowWhenCryptogramGeneratorNotPrepared { get; set; }
+   public SmartCardAutomaticResponseApdu( IBuffer commandApdu, IBuffer responseApdu );
+ }

+ public enum Windows.Devices.SmartCards.SmartCardAutomaticResponseStatus {
+   None = 0,
+   Success = 1,
+   UnknownError = 2,
+ }

+ public struct Windows.Devices.SmartCards.SmartCardBackgroundTriggerContract {
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramAlgorithm {
+   None = 0,
+   CbcMac = 1,
+   Cvc3Umd = 2,
+   DecimalizedMsd = 3,
+   Cvc3MD = 4,
+   Sha1 = 5,
+   SignedDynamicApplicationData = 6,
+   RsaPkcs1 = 7,
+   Sha256Hmac = 8,
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramGenerator {
+   public IVectorView<SmartCardCryptogramAlgorithm> SupportedCryptogramAlgorithms { get; }
+   public IVectorView<SmartCardCryptogramMaterialPackageConfirmationResponseFormat> SupportedCryptogramMaterialPackageConfirmationResponseFormats { get; }
+   public IVectorView<SmartCardCryptogramMaterialPackageFormat> SupportedCryptogramMaterialPackageFormats { get; }
+   public IVectorView<SmartCardCryptogramMaterialType> SupportedCryptogramMaterialTypes { get; }
+   public IVectorView<SmartCardCryptogramStorageKeyCapabilities> SupportedSmartCardCryptogramStorageKeyCapabilities { get; }
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> DeleteCryptogramMaterialStorageKeyAsync( string result );
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> CreateCryptogramMaterialStorageKeyAsync( SmartCardUnlockPromptingBehavior result, string promptingBehavior, SmartCardCryptogramStorageKeyAlgorithm storageKeyName, SmartCardCryptogramStorageKeyCapabilities algorithm );
+   public IAsyncOperation<SmartCardCryptogramStorageKeyInfo> RequestCryptogramMaterialStorageKeyInfoAsync( SmartCardUnlockPromptingBehavior result, string promptingBehavior, CryptographicPublicKeyBlobType storageKeyName );
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> ImportCryptogramMaterialPackageAsync( SmartCardCryptogramMaterialPackageFormat result, string format, string storageKeyName, IBuffer materialPackageName );
+   public IAsyncOperation<SmartCardCryptogramMaterialPossessionProof> TryProvePossessionOfCryptogramMaterialPackageAsync( SmartCardUnlockPromptingBehavior result, SmartCardCryptogramMaterialPackageConfirmationResponseFormat promptingBehavior, string responseFormat, string materialPackageName, IBuffer materialName );
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> RequestUnlockCryptogramMaterialForUseAsync( SmartCardUnlockPromptingBehavior result );
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> DeleteCryptogramMaterialPackageAsync( string result );
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> ValidateRequestApduAsync( SmartCardUnlockPromptingBehavior result, IBuffer promptingBehavior, IIterable<SmartCardCryptogramPlacementStep> apduToValidate );
+   public IAsyncOperation<SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult> GetAllCryptogramStorageKeyCharacteristicsAsync();
+   public IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync();
+   public IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync( string result );
+   public IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult> GetAllCryptogramMaterialCharacteristicsAsync( SmartCardUnlockPromptingBehavior result, string promptingBehavior );
+   public static bool IsSupported();
+   public static IAsyncOperation<SmartCardCryptogramGenerator> GetSmartCardCryptogramGeneratorAsync();
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramGeneratorOperationStatus {
+   Success = 0,
+   AuthorizationFailed = 1,
+   AuthorizationCanceled = 2,
+   AuthorizationRequired = 3,
+   CryptogramMaterialPackageStorageKeyExists = 4,
+   NoCryptogramMaterialPackageStorageKey = 5,
+   NoCryptogramMaterialPackage = 6,
+   UnsupportedCryptogramMaterialPackage = 7,
+   UnknownCryptogramMaterialName = 8,
+   InvalidCryptogramMaterialUsage = 9,
+   ApduResponseNotSent = 10,
+   OtherError = 11,
+   ValidationFailed = 12,
+   NotSupported = 13,
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult {
+   public IVectorView<SmartCardCryptogramMaterialCharacteristics> Characteristics { get; }
+   public SmartCardCryptogramGeneratorOperationStatus OperationStatus { get; }
+   public SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult();
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult {
+   public IVectorView<SmartCardCryptogramMaterialPackageCharacteristics> Characteristics { get; }
+   public SmartCardCryptogramGeneratorOperationStatus OperationStatus { get; }
+   public SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult();
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult {
+   public IVectorView<SmartCardCryptogramStorageKeyCharacteristics> Characteristics { get; }
+   public SmartCardCryptogramGeneratorOperationStatus OperationStatus { get; }
+   public SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult();
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramMaterialCharacteristics {
+   public IVectorView<SmartCardCryptogramAlgorithm> AllowedAlgorithms { get; }
+   public IVectorView<SmartCardCryptogramMaterialPackageConfirmationResponseFormat> AllowedProofOfPossessionAlgorithms { get; }
+   public IVectorView<SmartCardCryptogramAlgorithm> AllowedValidations { get; }
+   public int MaterialLength { get; }
+   public string MaterialName { get; }
+   public SmartCardCryptogramMaterialType MaterialType { get; }
+   public SmartCardCryptogramMaterialProtectionMethod ProtectionMethod { get; }
+   public int ProtectionVersion { get; }
+   public SmartCardCryptogramMaterialCharacteristics();
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramMaterialPackageCharacteristics {
+   public DateTime DateImported { get; }
+   public SmartCardCryptogramMaterialPackageFormat PackageFormat { get; }
+   public string PackageName { get; }
+   public string StorageKeyName { get; }
+   public SmartCardCryptogramMaterialPackageCharacteristics();
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramMaterialPackageConfirmationResponseFormat {
+   None = 0,
+   VisaHmac = 1,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramMaterialPackageFormat {
+   None = 0,
+   JweRsaPki = 1,
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramMaterialPossessionProof {
+   public SmartCardCryptogramGeneratorOperationStatus OperationStatus { get; }
+   public IBuffer Proof { get; }
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramMaterialProtectionMethod {
+   None = 0,
+   WhiteBoxing = 1,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramMaterialType {
+   None = 0,
+   StaticDataAuthentication = 1,
+   TripleDes112 = 2,
+   Aes = 3,
+   RsaPkcs1 = 4,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramPlacementOptions {
+   None = 0,
+   UnitsAreInNibbles = 1,
+   ChainOutput = 2,
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep {
+   public int TemplateOffset { get; set; }
+   public IBuffer SourceData { get; set; }
+   public SmartCardCryptogramPlacementOptions CryptogramPlacementOptions { get; set; }
+   public int CryptogramOffset { get; set; }
+   public string CryptogramMaterialPackageName { get; set; }
+   public string CryptogramMaterialName { get; set; }
+   public int CryptogramLength { get; set; }
+   public SmartCardCryptogramPlacementStep ChainedOutputStep { get; set; }
+   public SmartCardCryptogramAlgorithm Algorithm { get; set; }
+   public SmartCardCryptogramPlacementStep();
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyAlgorithm {
+   None = 0,
+   Rsa2048 = 1,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyCapabilities {
+   None = 0,
+   HardwareProtection = 1,
+   UnlockPrompt = 2,
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyCharacteristics {
+   public SmartCardCryptogramStorageKeyAlgorithm Algorithm { get; }
+   public SmartCardCryptogramStorageKeyCapabilities Capabilities { get; }
+   public DateTime DateCreated { get; }
+   public string StorageKeyName { get; }
+   public SmartCardCryptogramStorageKeyCharacteristics();
+ }

+ public class Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyInfo {
+   public IBuffer Attestation { get; }
+   public IBuffer AttestationCertificateChain { get; }
+   public SmartCardCryptographicKeyAttestationStatus AttestationStatus { get; }
+   public SmartCardCryptogramStorageKeyCapabilities Capabilities { get; }
+   public SmartCardCryptogramGeneratorOperationStatus OperationStatus { get; }
+   public IBuffer PublicKey { get; }
+   public CryptographicPublicKeyBlobType PublicKeyBlobType { get; }
+   public string OperationalRequirements { get; }
+ }

+ public enum Windows.Devices.SmartCards.SmartCardCryptographicKeyAttestationStatus {
+   NoAttestation = 0,
+   SoftwareKeyWithoutTpm = 1,
+   SoftwareKeyWithTpm = 2,
+   TpmKeyUnknownAttestationStatus = 3,
+   TpmKeyWithoutAttestationCapability = 4,
+   TpmKeyWithTemporaryAttestationFailure = 5,
+   TpmKeyWithLongTermAttestationFailure = 6,
+   TpmKeyWithAttestation = 7,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulationCategory {
+   Other = 0,
+   Payment = 1,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulationType {
+   Host = 0,
+   Uicc = 1,
+   EmbeddedSE = 2,
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulator {
+   public SmartCardEmulatorEnablementPolicy EnablementPolicy { get; }
+   public ushort MaxAppletIdGroupRegistrations { get; }
+   public void Start();
+   public bool IsHostCardEmulationSupported();
+   public static bool IsSupported();
+   public static IAsyncOperation<IVectorView<SmartCardAppletIdGroupRegistration>> GetAppletIdGroupRegistrationsAsync();
+   public static IAsyncOperation<SmartCardAppletIdGroupRegistration> RegisterAppletIdGroupAsync( SmartCardAppletIdGroup result );
+   public static IAsyncAction UnregisterAppletIdGroupAsync( SmartCardAppletIdGroupRegistration result );
+   public static IAsyncOperation<SmartCardEmulator> GetDefaultAsync();
+   TypedEventHandler<SmartCardEmulator, SmartCardEmulatorApduReceivedEventArgs> ApduReceived;
+   TypedEventHandler<SmartCardEmulator, SmartCardEmulatorConnectionDeactivatedEventArgs> ConnectionDeactivated;
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs {
+   public SmartCardAutomaticResponseStatus AutomaticResponseStatus { get; }
+   public IBuffer CommandApdu { get; }
+   public SmartCardEmulatorConnectionProperties ConnectionProperties { get; }
+   public uint State { get; }
+   public IAsyncOperation<bool> TryRespondAsync( IBuffer result );
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> TryRespondWithCryptogramsAsync( IBuffer result, IIterable<SmartCardCryptogramPlacementStep> responseTemplate );
+   public IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> TryRespondWithCryptogramsAsync( IBuffer result, IIterable<SmartCardCryptogramPlacementStep> responseTemplate, IReference<uint> cryptogramPlacementSteps );
+   public IAsyncOperation<bool> TryRespondAsync( IBuffer result, IReference<uint> responseApdu );
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs {
+   public SmartCardEmulatorConnectionProperties ConnectionProperties { get; }
+   public SmartCardEmulatorConnectionDeactivatedReason Reason { get; }
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedReason {
+   ConnectionLost = 0,
+   ConnectionRedirected = 1,
+ }

+ public class Windows.Devices.SmartCards.SmartCardEmulatorConnectionProperties {
+   public Guid Id { get; }
+   public SmartCardEmulatorConnectionSource Source { get; }
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulatorConnectionSource {
+   Unknown = 0,
+   NfcReader = 1,
+ }

+ public struct Windows.Devices.SmartCards.SmartCardEmulatorContract {
+ }

+ public enum Windows.Devices.SmartCards.SmartCardEmulatorEnablementPolicy {
+   Never = 0,
+   Always = 1,
+   ScreenOn = 2,
+   ScreenUnlocked = 3,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardLaunchBehavior {
+   Default = 0,
+   AboveLock = 1,
+ }

+ public class Windows.Devices.SmartCards.SmartCardTriggerDetails {
+   public IBuffer SourceAppletId { get; }
+   public IBuffer TriggerData { get; }
+   public SmartCardTriggerType TriggerType { get; }
+   public SmartCardEmulator Emulator { get; }
+   public SmartCard SmartCard { get; }
+   public IAsyncOperation<bool> TryLaunchCurrentAppAsync( string result );
+   public IAsyncOperation<bool> TryLaunchCurrentAppAsync( string result, SmartCardLaunchBehavior arguments );
+ }

+ public enum Windows.Devices.SmartCards.SmartCardTriggerType {
+   EmulatorTransaction = 0,
+   EmulatorNearFieldEntry = 1,
+   EmulatorNearFieldExit = 2,
+   EmulatorHostApplicationActivated = 3,
+   EmulatorAppletIdGroupRegistrationChanged = 4,
+   ReaderCardAdded = 5,
+ }

+ public enum Windows.Devices.SmartCards.SmartCardUnlockPromptingBehavior {
+   AllowUnlockPrompt = 0,
+   RequireUnlockPrompt = 1,
+   PreventUnlockPrompt = 2,
+ }

| public class Windows.Devices.WiFi.WiFiAdapter {
+   public IAsyncOperation<WiFiWpsConfigurationResult> GetWpsConfigurationAsync( WiFiAvailableNetwork operation );
+   public IAsyncOperation<WiFiConnectionResult> ConnectAsync( WiFiAvailableNetwork operation, WiFiReconnectionKind availableNetwork, PasswordCredential reconnectionKind, string passwordCredential, WiFiConnectionMethod ssid );
| }

+ public enum Windows.Devices.WiFi.WiFiConnectionMethod {
+   Default = 0,
+   WpsPin = 1,
+   WpsPushButton = 2,
+ }

+ public class Windows.Devices.WiFi.WiFiWpsConfigurationResult {
+   public WiFiWpsConfigurationStatus Status { get; }
+   public IVectorView<WiFiWpsKind> SupportedWpsKinds { get; }
+ }

+ public enum Windows.Devices.WiFi.WiFiWpsConfigurationStatus {
+   UnspecifiedFailure = 0,
+   Success = 1,
+   Timeout = 2,
+ }

+ public enum Windows.Devices.WiFi.WiFiWpsKind {
+   Unknown = 0,
+   Pin = 1,
+   PushButton = 2,
+   Nfc = 3,
+   Ethernet = 4,
+   Usb = 5,
+ }

+ public class Windows.Foundation.Diagnostics.DiagnosticsInvoker {
+   public static IAsyncOperationWithProgress<ValueSet, int> ExecuteDiagnosticsPackageAsync( string operation, string sessionId, ValueSet actionId );
+ }

| public class Windows.Gaming.Input.RawGameController {
+   public string DisplayName { get; }
+   public string NonRoamableId { get; }
+   public IVectorView<SimpleHapticsController> SimpleHapticsControllers { get; }
| }

| public class Windows.Gaming.Preview.GamesEnumeration.GameList {
+   public static IAsyncOperation<GameListEntry> MergeEntriesAsync( GameListEntry operation, GameListEntry left );
+   public static IAsyncOperation<IVectorView<GameListEntry>> UnmergeEntryAsync( GameListEntry operation );
| }

| public class Windows.Gaming.Preview.GamesEnumeration.GameListEntry {
+   public GameModeConfiguration GameModeConfiguration { get; }
+   public string LaunchParameters { get; }
+   public GameListEntryLaunchableState LaunchableState { get; }
+   public IStorageFile LauncherExecutable { get; }
+   public string TitleId { get; }
+   public IAsyncAction SetLauncherExecutableFileAsync( IStorageFile operation );
+   public IAsyncAction SetLauncherExecutableFileAsync( IStorageFile operation, string executableFile );
+   public IAsyncAction SetTitleIdAsync( string operation );
| }

+ public enum Windows.Gaming.Preview.GamesEnumeration.GameListEntryLaunchableState {
+   NotLaunchable = 0,
+   ByLastRunningFullPath = 1,
+   ByUserProvidedPath = 2,
+   ByTile = 3,
+ }

+ public class Windows.Gaming.Preview.GamesEnumeration.GameModeConfiguration {
+   public IReference<int> PercentGpuTimeAllocatedToGame { get; set; }
+   public IReference<int> PercentGpuMemoryAllocatedToSystemCompositor { get; set; }
+   public IReference<int> PercentGpuMemoryAllocatedToGame { get; set; }
+   public IReference<int> MaxCpuCount { get; set; }
+   public bool IsEnabled { get; set; }
+   public IReference<int> CpuExclusivityMaskLow { get; set; }
+   public IReference<int> CpuExclusivityMaskHigh { get; set; }
+   public bool AffinitizeToExclusiveCpus { get; set; }
+   public IVector<string> RelatedProcessNames { get; }
+   public IAsyncAction SaveAsync();
+ }

+ public class Windows.Gaming.Preview.GamesEnumeration.GameModeUserConfiguration {
+   public IVector<string> GamingRelatedProcessNames { get; }
+   public IAsyncAction SaveAsync();
+   public static GameModeUserConfiguration GetDefault();
+ }

+ public class Windows.Gaming.UI.GameMonitor {
+   public IAsyncOperation<GameMonitoringPermission> RequestPermissionAsync();
+   public static GameMonitor GetDefault();
+ }

+ public enum Windows.Gaming.UI.GameMonitoringPermission {
+   Allowed = 0,
+   DeniedByUser = 1,
+   DeniedBySystem = 2,
+ }

+ public class Windows.Gaming.UI.GameUIProviderActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public ValueSet GameUIArgs { get; }
+   public void ReportCompleted( ValueSet results );
+ }

+ public struct Windows.Gaming.UI.GamingUIProviderContract {
+ }

| public class Windows.Graphics.Holographic.HolographicCamera {
+   public PresentationLayerDrmMode DrmMode { get; set; }
+   public PresentationLayerConfig CreateLayerConfig();
+   public void SetLayerConfig( PresentationLayerConfig layerConfig );
+   public PresentationLayers GetPresentationLayers();
| }

| public class Windows.Graphics.Holographic.HolographicCameraRenderingParameters {
+   public PresentationLayerRenderingParametersQuad GetPresentationLayerRenderingParameters( PresentationLayerQuad result );
| }

| public class Windows.Graphics.Holographic.HolographicDisplay {
+   public double RefreshRate { get; }
| }

| public class Windows.Graphics.Holographic.HolographicSpace {
+   public bool IsConfigured { get; }
| }

+ public class Windows.Graphics.Holographic.PresentationLayerConfig {
+   public IVectorView<PresentationLayerSettings> PresentationLayerSettings { get; }
+ }

+ public enum Windows.Graphics.Holographic.PresentationLayerDrmMode {
+   Disable = 0,
+   SoftwareEncryption = 1,
+ }

+ public class Windows.Graphics.Holographic.PresentationLayerQuad {
+   public Direct3DSurfaceDescription TextureDesc { get; set; }
+   public HolographicReprojectionMode ReprojectionMode { get; set; }
+   public PresentationLayerDrmMode DrmMode { get; set; }
+ }

+ public class Windows.Graphics.Holographic.PresentationLayerReference {
+   public PresentationLayerQuad Quad { get; }
+   public PresentationLayerType Type { get; }
+ }

+ public class Windows.Graphics.Holographic.PresentationLayerRenderingParametersQuad {
+   public IDirect3DSurface Direct3D11ContentBuffer { get; }
+   public PresentationLayerDrmMode DrmMode { get; }
+   public void SetQuadPlaneParameters( SpatialCoordinateSystem positionedAndOrientedCoordinateSystem, Vector2 extents );
+ }

+ public class Windows.Graphics.Holographic.PresentationLayerSettings {
+   public bool Enabled { get; set; }
+   public PresentationLayerType Type { get; }
+ }

+ public enum Windows.Graphics.Holographic.PresentationLayerType {
+   World = 0,
+   Quad = 1,
+ }

+ public class Windows.Graphics.Holographic.PresentationLayers {
+   public IVectorView<PresentationLayerReference> Layers { get; }
+ }

| public class Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration {
+   public string SessionId { get; }
+   public string SourceAppDisplayName { get; }
-   public string SourceApplicationExecutableName { get; }
| }

+ public enum Windows.Management.Deployment.AddPackageByAppInstallerOptions {
+   None = 0,
+   InstallAllResources = 32,
+   ForceTargetAppShutdown = 64,
+   RequiredContentGroupOnly = 256,
+ }

| public class Windows.Management.Deployment.PackageManager {
+   public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> ProvisionPackageForAllUsersAsync( string operation );
+   public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageByAppInstallerFileAsync( Uri operation, AddPackageByAppInstallerOptions appInstallerFileUri, PackageVolume options );
+   public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageByAppInstallerFileAsync( Uri operation, AddPackageByAppInstallerOptions appInstallerFileUri, PackageVolume options );
+   public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync( Uri operation, IIterable<Uri> packageUri, DeploymentOptions dependencyPackageUris, PackageVolume options, IIterable<string> targetVolume, IIterable<Uri> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall );
+   public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync( Uri operation, IIterable<Uri> packageUri, DeploymentOptions dependencyPackageUris, PackageVolume options, IIterable<string> targetVolume, IIterable<Uri> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall );
+   public IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync( Uri operation, IIterable<Uri> packageUri, DeploymentOptions dependencyPackageUris, PackageVolume deploymentOptions, IIterable<string> targetVolume, IIterable<Uri> optionalPackageFamilyNames );
| }

+ public struct Windows.Media.AppBroadcasting.AppBroadcastingContract {
+ }

+ public class Windows.Media.AppBroadcasting.AppBroadcastingMonitor {
+   public bool IsCurrentAppBroadcasting { get; }
+   public AppBroadcastingMonitor();
+   TypedEventHandler<AppBroadcastingMonitor, object> IsCurrentAppBroadcastingChanged;
+ }

+ public class Windows.Media.AppBroadcasting.AppBroadcastingStatus {
+   public bool CanStartBroadcast { get; }
+   public AppBroadcastingStatusDetails Details { get; }
+ }

+ public class Windows.Media.AppBroadcasting.AppBroadcastingStatusDetails {
+   public bool IsAnyAppBroadcasting { get; }
+   public bool IsAppInactive { get; }
+   public bool IsBlockedForApp { get; }
+   public bool IsCaptureResourceUnavailable { get; }
+   public bool IsDisabledBySystem { get; }
+   public bool IsDisabledByUser { get; }
+   public bool IsGameStreamInProgress { get; }
+   public bool IsGpuConstrained { get; }
+ }

+ public class Windows.Media.AppBroadcasting.AppBroadcastingUI {
+   public AppBroadcastingStatus GetStatus();
+   public void ShowBroadcastUI();
+   public static AppBroadcastingUI GetDefault();
+   public static AppBroadcastingUI GetForUser( User result );
+ }

+ public struct Windows.Media.AppRecording.AppRecordingContract {
+ }

+ public class Windows.Media.AppRecording.AppRecordingManager {
+   public IVectorView<string> SupportedScreenshotMediaEncodingSubtypes { get; }
+   public AppRecordingStatus GetStatus();
+   public IAsyncOperation<AppRecordingResult> StartRecordingToFileAsync( StorageFile operation );
+   public IAsyncOperation<AppRecordingResult> RecordTimeSpanToFileAsync( DateTime operation, TimeSpan startTime, StorageFile duration );
+   public IAsyncOperation<AppRecordingSaveScreenshotResult> SaveScreenshotToFilesAsync( StorageFolder operation, string folder, AppRecordingSaveScreenshotOption filenamePrefix, IIterable<string> option );
+   public static AppRecordingManager GetDefault();
+ }

+ public class Windows.Media.AppRecording.AppRecordingResult {
+   public TimeSpan Duration { get; }
+   public HResult ExtendedError { get; }
+   public bool IsFileTruncated { get; }
+   public bool Succeeded { get; }
+ }

+ public enum Windows.Media.AppRecording.AppRecordingSaveScreenshotOption {
+   None = 0,
+   HdrContentVisible = 1,
+ }

+ public class Windows.Media.AppRecording.AppRecordingSaveScreenshotResult {
+   public HResult ExtendedError { get; }
+   public IVectorView<AppRecordingSavedScreenshotInfo> SavedScreenshotInfos { get; }
+   public bool Succeeded { get; }
+ }

+ public class Windows.Media.AppRecording.AppRecordingSavedScreenshotInfo {
+   public StorageFile File { get; }
+   public string MediaEncodingSubtype { get; }
+ }

+ public class Windows.Media.AppRecording.AppRecordingStatus {
+   public bool CanRecord { get; }
+   public bool CanRecordTimeSpan { get; }
+   public AppRecordingStatusDetails Details { get; }
+   public TimeSpan HistoricalBufferDuration { get; }
+ }

+ public class Windows.Media.AppRecording.AppRecordingStatusDetails {
+   public bool IsAnyAppBroadcasting { get; }
+   public bool IsAppInactive { get; }
+   public bool IsBlockedForApp { get; }
+   public bool IsCaptureResourceUnavailable { get; }
+   public bool IsDisabledBySystem { get; }
+   public bool IsDisabledByUser { get; }
+   public bool IsGameStreamInProgress { get; }
+   public bool IsGpuConstrained { get; }
+   public bool IsTimeSpanRecordingDisabled { get; }
+ }

| public class Windows.Media.Capture.AppBroadcastBackgroundService {
*   public string BroadcastTitle { get; set; }
+   public string BroadcastLanguage { get; set; }
+   public string BroadcastChannel { get; set; }
| }

| public class Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo {
+   public void ReportProblemWithStream();
| }

| public class Windows.Media.Capture.AppCapture {
+   public static IAsyncAction SetAllowedAsync( bool operation );
| }

+ public struct Windows.Media.Capture.AppCaptureMetadataContract {
+ }

+ public enum Windows.Media.Capture.AppCaptureMetadataPriority {
+   Informational = 0,
+   Important = 1,
+ }

+ public class Windows.Media.Capture.AppCaptureMetadataWriter {
+   public ulong RemainingStorageBytesAvailable { get; }
+   public AppCaptureMetadataWriter();
+   public void AddStringEvent( string name, string value, AppCaptureMetadataPriority priority );
+   public void AddInt32Event( string name, int value, AppCaptureMetadataPriority priority );
+   public void AddDoubleEvent( string name, double value, AppCaptureMetadataPriority priority );
+   public void StartStringState( string name, string value, AppCaptureMetadataPriority priority );
+   public void StartInt32State( string name, int value, AppCaptureMetadataPriority priority );
+   public void StartDoubleState( string name, double value, AppCaptureMetadataPriority priority );
+   public void StopState( string name );
+   public void StopAllStates();
+   public void Close();
+   TypedEventHandler<AppCaptureMetadataWriter, object> MetadataPurged;
+ }

| public class Windows.Media.Core.AudioStreamDescriptor {
+   public string Label { get; set; }
| }

+ public interface Windows.Media.Core.IMediaStreamDescriptor2 {
+   public string Label { get; set; }
+ }

+ public class Windows.Media.Core.LowLightFusion {
+   public int MaxSupportedFrameCount { get; }
+   public IVectorView<BitmapPixelFormat> SupportedBitmapPixelFormats { get; }
+   public static IAsyncOperationWithProgress<LowLightFusionResult, double> FuseAsync( IIterable<SoftwareBitmap> result );
+ }

+ public class Windows.Media.Core.LowLightFusionResult {
+   public SoftwareBitmap Frame { get; }
+   public void Close();
+ }

| public class Windows.Media.Core.MediaSource {
-   public static MediaSource CreateFromMediaFrameSource( MediaFrameSource result );
-   public static MediaSource CreateFromDownloadOperation( DownloadOperation result );
| }

| public class Windows.Media.Core.SceneAnalysisEffectFrame {
+   public SceneAnalysisRecommendation AnalysisRecommendation { get; }
| }

+ public enum Windows.Media.Core.SceneAnalysisRecommendation {
+   Standard = 0,
+   Hdr = 1,
+   LowLight = 2,
+ }

| public class Windows.Media.Core.VideoStreamDescriptor {
+   public string Label { get; set; }
| }

+ public class Windows.Media.DialProtocol.DialReceiverApp {
+   public DialReceiverApp Current { get; }
+   public IAsyncOperation<IMap<string, string>> GetAdditionalDataAsync();
+   public IAsyncAction SetAdditionalDataAsync( IIterable<IKeyValuePair<string, string>> operation );
+ }

| public class Windows.Media.MediaProperties.MediaEncodingProfile {
+   public void SetAudioTracks( IIterable<AudioStreamDescriptor> value );
+   public IVector<AudioStreamDescriptor> GetAudioTracks();
+   public void SetVideoTracks( IIterable<VideoStreamDescriptor> value );
+   public IVector<VideoStreamDescriptor> GetVideoTracks();
| }

| public class Windows.Media.SpeechSynthesis.SpeechSynthesizer {
+   public static IAsyncOperation<bool> TrySetDefaultVoiceAsync( VoiceInformation result );
| }

| public class Windows.Media.SpeechSynthesis.SpeechSynthesizerOptions {
+   public double SpeakingRate { get; set; }
+   public double AudioVolume { get; set; }
+   public double AudioPitch { get; set; }
| }

+ public struct Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange {
+   public ulong Offset;
+   public ulong Length;
+ }

+ public class Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs {
+   public IVector<BackgroundTransferFileRange> AddedRanges { get; }
+   public bool WasDownloadRestarted { get; }
+   public Deferral GetDeferral();
+ }

| public enum Windows.Networking.BackgroundTransfer.BackgroundTransferStatus {
+   PausedRecoverableWebErrorStatus = 8,
| }

| public class Windows.Networking.BackgroundTransfer.DownloadOperation {
*   public Uri RequestedUri { get; set; }
+   public bool IsRandomAccessRequired { get; set; }
+   public IReference<WebErrorStatus> CurrentWebErrorStatus { get; }
+   public IVector<WebErrorStatus> RecoverableWebErrorStatuses { get; }
+   public IRandomAccessStreamReference GetResultRandomAccessStreamReference();
+   public IVector<BackgroundTransferFileRange> GetDownloadedRanges();
| }

| public class Windows.Networking.Connectivity.ConnectionProfile {
+   public IAsyncOperation<IVectorView<ProviderNetworkUsage>> GetProviderNetworkUsageAsync( DateTime value, DateTime startTime, NetworkUsageStates endTime );
| }

+ public class Windows.Networking.Connectivity.ProviderNetworkUsage {
+   public ulong BytesReceived { get; }
+   public ulong BytesSent { get; }
+   public string ProviderId { get; }
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandAntenna {
+   public int AntennaIndex { get; }
+   public int SarBackoffIndex { get; }
+ }

| public class Windows.Networking.NetworkOperators.MobileBroadbandModem {
+   public IAsyncOperation<bool> GetIsPassthroughEnabledAsync();
+   public IAsyncOperation<MobileBroadbandModemStatus> SetIsPassthroughEnabledAsync( bool asyncInfo );
| }

| public class Windows.Networking.NetworkOperators.MobileBroadbandModemConfiguration {
+   public IAsyncOperation<MobileBroadbandSarManager> GetSarManagerAsync();
| }

+ public enum Windows.Networking.NetworkOperators.MobileBroadbandModemStatus {
+   Success = 0,
+   OtherFailure = 1,
+   Busy = 2,
+   NoDeviceSupport = 3,
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandSarManager {
+   public IVectorView<MobileBroadbandAntenna> AntennaConfiguration { get; }
+   public TimeSpan HysteresisTimer { get; }
+   public bool IsBackoffEnabled { get; }
+   public bool IsSarControlledByHardware { get; }
+   public bool IsWiFiHardwareIntegrated { get; }
+   public IAsyncAction ConfigureSarAsync( bool asyncInfo, IIterable<MobileBroadbandAntenna> backoffEnabled );
+   public IAsyncAction RevertSarToHardwareControlAsync();
+   public IAsyncAction ConfigureHysteresisTimerAsync( TimeSpan asyncInfo );
+   public IAsyncOperation<bool> QueryTransmissionStateAsync();
+   TypedEventHandler<MobileBroadbandSarManager, MobileBroadbandTransmissionStateChangedEventArgs> TransmissionStateChanged;
+ }

+ public class Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs {
+   public TimeSpan HysteresisTimer { get; }
+   public bool IsTransmissionStateActive { get; }
+ }

| public class Windows.Networking.Sockets.MessageWebSocketControl {
+   public MessageWebSocketReceiveMode ReceiveMode { get; set; }
+   public TimeSpan DesiredUnsolicitedPongInterval { get; set; }
+   public Certificate ClientCertificate { get; set; }
+   public TimeSpan ActualUnsolicitedPongInterval { get; }
| }

| public class Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs {
+   public bool IsMessageComplete { get; }
| }

+ public enum Windows.Networking.Sockets.MessageWebSocketReceiveMode {
+   FullMessage = 0,
+   PartialMessage = 1,
+ }

| public enum Windows.Networking.Sockets.SocketProtectionLevel {
+   Unspecified = 9,
| }

| public class Windows.Networking.Sockets.StreamSocketControl {
+   public SocketProtectionLevel MinProtectionLevel { get; set; }
| }

| public class Windows.Networking.Sockets.StreamWebSocketControl {
+   public TimeSpan DesiredUnsolicitedPongInterval { get; set; }
+   public Certificate ClientCertificate { get; set; }
+   public TimeSpan ActualUnsolicitedPongInterval { get; }
| }

| public class Windows.Security.EnterpriseData.FileProtectionInfo {
+   public bool IsProtectWhileOpenSupported { get; }
| }

| public class Windows.Services.Maps.MapRoute {
+   public bool IsScenic { get; }
| }

| public enum Windows.Services.Maps.MapRouteOptimization {
+   Scenic = 3,
| }

+ public class Windows.Services.Maps.PlaceInfo {
+   public string DisplayAddress { get; }
+   public string DisplayName { get; }
+   public IGeoshape Geoshape { get; }
+   public string Identifier { get; }
+   public bool IsShowSupported { get; }
+   public void Show( Rect selection );
+   public void Show( Rect selection, Placement preferredPlacement );
+   public static PlaceInfo Create( Geopoint resultValue );
+   public static PlaceInfo Create( Geopoint resultValue, PlaceInfoCreateOptions referencePoint );
+   public static PlaceInfo CreateFromIdentifier( string resultValue );
+   public static PlaceInfo CreateFromIdentifier( string resultValue, Geopoint identifier, PlaceInfoCreateOptions defaultPoint );
+   public static PlaceInfo CreateFromMapLocation( MapLocation resultValue );
+ }

+ public class Windows.Services.Maps.PlaceInfoCreateOptions {
+   public string DisplayName { get; set; }
+   public string DisplayAddress { get; set; }
+   public PlaceInfoCreateOptions();
+ }

| public class Windows.Services.Maps.Guidance.GuidanceRoadSegment {
+   public bool IsScenic { get; }
| }

+ public class Windows.Services.Maps.LocalSearch.PlaceInfoHelper {
+   public static PlaceInfo CreateFromLocalLocation( LocalLocation resultValue );
+ }

| public class Windows.Storage.StorageProvider {
+   public IAsyncOperation<bool> IsPropertySupportedForPartialFileAsync( string operation );
| }

+ public class Windows.Storage.FileProperties.StorageItemCustomProperties {
+   public static IAsyncAction SetItemCustomPropertiesAsync( IStorageItem operation, IIterable<StorageItemCustomProperty> item );
+ }

+ public class Windows.Storage.FileProperties.StorageItemCustomProperty {
+   public string Value { get; set; }
+   public uint Id { get; set; }
+   public string IconReference { get; set; }
+   public StorageItemCustomProperty();
+ }

+ public struct Windows.Storage.Provider.CloudFilesContract {
+ }

| public class Windows.Storage.Provider.CustomStateDefinition {
-   public int StateID;
-   public string DisplayName;
+   public int StateId { get; set; }
+   public string DisplayName { get; set; }
+   public CustomStateDefinition();
| }

+ public interface Windows.Storage.Provider.IStorageProviderCustomPropertyHandler {
+   public IIterable<StorageItemCustomProperty> GetCustomProperties( string stateList );
+ }

+ public interface Windows.Storage.Provider.IStorageProviderPropertyCapabilities {
+   public bool IsPropertySupported( string isSupported );
+ }

| public class Windows.Storage.Provider.SyncRootInformation {
*   public IStorageFolder Path { get; set; }
+   public string Id { get; set; }
-   public string ID { get; set; }
| }

| public class Windows.Storage.Provider.SyncRootManager {
-   public IVectorView<SyncRootInformation> CurrentSyncRoots { get; }
+   public static void Register( SyncRootInformation syncRootInformation );
+   public static void Unregister( SyncRootInformation syncRootInformation );
+   public static SyncRootInformation GetSyncRootInformationFromPath( string syncRootInformation );
+   public static SyncRootInformation GetSyncRootInformationFromId( string syncRootInformation );
+   public static IVectorView<SyncRootInformation> GetCurrentSyncRoots();
-   public SyncRootManager();
| }

| public enum Windows.Storage.Search.IndexerOption {
+   OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
| }

| public class Windows.System.AppDiagnosticInfo {
+   public IVector<AppResourceGroupInfo> GetResourceGroups();
+   public AppResourceGroupInfoWatcher CreateResourceGroupWatcher();
+   public static IAsyncOperation<DiagnosticAccessStatus> RequestAccessAsync();
+   public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForAppAsync();
-   public static IAsyncOperation<DiagnosticPermission> RequestPermissionAsync();
| }

+ public class Windows.System.AppResourceGroupBackgroundTaskReport {
+   public string EntryPoint { get; }
+   public string Name { get; }
+   public Guid TaskId { get; }
+   public string Trigger { get; }
+ }

+ public enum Windows.System.AppResourceGroupEnergyQuotaState {
+   Unknown = 0,
+   Over = 1,
+   Under = 2,
+ }

+ public enum Windows.System.AppResourceGroupExecutionState {
+   Unknown = 0,
+   Running = 1,
+   Suspending = 2,
+   Suspended = 3,
+   NotRunning = 4,
+ }

+ public class Windows.System.AppResourceGroupInfo {
+   public Guid InstanceId { get; }
+   public bool IsShared { get; }
+   public IVector<AppResourceGroupBackgroundTaskReport> GetBackgroundTaskReports();
+   public AppResourceGroupMemoryReport GetMemoryReport();
+   public IVector<ProcessDiagnosticInfo> GetProcessDiagnosticInfos();
+   public AppResourceGroupStateReport GetStateReport();
+ }

+ public class Windows.System.AppResourceGroupInfoWatcher {
+   public AppResourceGroupInfoWatcherStatus Status { get; }
+   public void Start();
+   public void Stop();
+   TypedEventHandler<AppResourceGroupInfoWatcher, AppResourceGroupInfoWatcherEventArgs> Added;
+   TypedEventHandler<AppResourceGroupInfoWatcher, object> EnumerationCompleted;
+   TypedEventHandler<AppResourceGroupInfoWatcher, AppResourceGroupInfoWatcherExecutionStateChangedEventArgs> ExecutionStateChanged;
+   TypedEventHandler<AppResourceGroupInfoWatcher, AppResourceGroupInfoWatcherEventArgs> Removed;
+   TypedEventHandler<AppResourceGroupInfoWatcher, object> Stopped;
+ }

+ public class Windows.System.AppResourceGroupInfoWatcherEventArgs {
+   public IVectorView<AppDiagnosticInfo> AppDiagnosticInfos { get; }
+   public AppResourceGroupInfo AppResourceGroupInfo { get; }
+ }

+ public class Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs {
+   public IVectorView<AppDiagnosticInfo> AppDiagnosticInfos { get; }
+   public AppResourceGroupInfo AppResourceGroupInfo { get; }
+ }

+ public enum Windows.System.AppResourceGroupInfoWatcherStatus {
+   Created = 0,
+   Started = 1,
+   EnumerationCompleted = 2,
+   Stopping = 3,
+   Stopped = 4,
+   Aborted = 5,
+ }

+ public class Windows.System.AppResourceGroupMemoryReport {
+   public AppMemoryUsageLevel CommitUsageLevel { get; }
+   public ulong CommitUsageLimit { get; }
+   public ulong PrivateCommitUsage { get; }
+   public ulong TotalCommitUsage { get; }
+ }

+ public class Windows.System.AppResourceGroupStateReport {
+   public AppResourceGroupEnergyQuotaState EnergyQuotaState { get; }
+   public AppResourceGroupExecutionState ExecutionState { get; }
+ }

- public class Windows.System.BackgroundTaskReport;

+ public class Windows.System.DateTimeSettings {
+   public static void SetSystemDateTime( DateTime utcDateTime );
+ }

+ public enum Windows.System.DiagnosticAccessStatus {
+   Unspecified = 0,
+   Denied = 1,
+   Limited = 2,
+   Allowed = 3,
+ }

- public enum Windows.System.DiagnosticPermission;

| public class Windows.System.DispatcherQueueController {
+   public static DispatcherQueueController CreateOnDedicatedThread();
-   public static DispatcherQueueController CreateQueueWithDedicatedThread();
| }

+ public class Windows.System.DispatcherQueueShutdownStartingEventArgs {
+   public Deferral GetDeferral();
+ }

| public class Windows.System.DispatcherQueueTimer {
+   public bool IsRunning { get; }
-   public bool IsStarted { get; }
| }

- public enum Windows.System.EnergyQuotaState;

- public enum Windows.System.ExecutionState;

- public class Windows.System.MemoryReport;

- public class Windows.System.ResourceGroupInfo;

- public class Windows.System.ResourceGroupInfoWatcher;

- public class Windows.System.ResourceGroupInfoWatcherEventArgs;

- public class Windows.System.ResourceGroupInfoWatcherExecutionStateChangedEventArgs;

- public enum Windows.System.ResourceGroupInfoWatcherStatus;

- public class Windows.System.StateReport;

| public class Windows.System.Diagnostics.ProcessDiagnosticInfo {
+   public IVector<AppDiagnosticInfo> GetAppDiagnosticInfos();
+   public static ProcessDiagnosticInfo TryGetForProcessId( uint result );
-   public IVector<AppDiagnosticInfo> TryGetAppDiagnosticInfo();
| }

| public enum Windows.System.Profile.SystemIdentificationSource {
+   Registry = 3,
| }

| public class Windows.System.RemoteSystems.RemoteSystem {
+   public string ManufacturerDisplayName { get; }
+   public string ModelDisplayName { get; }
| }

| public class Windows.System.RemoteSystems.RemoteSystemKinds {
+   public string Iot { get; }
+   public string Laptop { get; }
+   public string Tablet { get; }
| }

- public class Windows.UI.Composition.CompositionAnchor : Windows.UI.Composition.CompositionObject;

| public class Windows.UI.Composition.CompositionAnimation : Windows.UI.Composition.CompositionObject {
+   public InitialValueExpressions InitialValueExpressions { get; }
-   public ExpressionProperties ExpressionProperties { get; }
| }

+ public class Windows.UI.Composition.CompositionColorGradientStop : Windows.UI.Composition.CompositionObject {
+   public float Offset { get; set; }
+   public Color Color { get; set; }
+ }

+ public class Windows.UI.Composition.CompositionColorGradientStopCollection {
+   public uint Size { get; }
+   public CompositionColorGradientStop GetAt( uint returnValue );
+   public IVectorView<CompositionColorGradientStop> GetView();
+   public bool IndexOf( CompositionColorGradientStop returnValue, ref uint value );
+   public void SetAt( uint index, CompositionColorGradientStop value );
+   public void InsertAt( uint index, CompositionColorGradientStop value );
+   public void RemoveAt( uint index );
+   public void Append( CompositionColorGradientStop value );
+   public void RemoveAtEnd();
+   public void Clear();
+   public uint GetMany( uint returnValue, CompositionColorGradientStop[] startIndex );
+   public void ReplaceAll( CompositionColorGradientStop[] items );
+   public IIterator<CompositionColorGradientStop> First();
+ }

| public enum Windows.UI.Composition.CompositionColorSpace {
+   HslLinear = 3,
+   RgbLinear = 4,
| }

+ public class Windows.UI.Composition.CompositionGradientBrush : Windows.UI.Composition.CompositionBrush {
+   public Matrix3x2 TransformMatrix { get; set; }
+   public Vector2 Scale { get; set; }
+   public float RotationAngleInDegrees { get; set; }
+   public float RotationAngle { get; set; }
+   public Vector2 Offset { get; set; }
+   public CompositionColorSpace InterpolationSpace { get; set; }
+   public CompositionGradientExtendMode ExtendMode { get; set; }
+   public Vector2 CenterPoint { get; set; }
+   public Vector2 AnchorPoint { get; set; }
+   public CompositionColorGradientStopCollection ColorStops { get; }
+ }

+ public enum Windows.UI.Composition.CompositionGradientExtendMode {
+   Clamp = 0,
+   Wrap = 1,
+   Mirror = 2,
+ }

- public class Windows.UI.Composition.CompositionIsland : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.CompositionIslandEventArgs;

- public enum Windows.UI.Composition.CompositionIslandVisibilityHints;

| public class Windows.UI.Composition.CompositionLight : Windows.UI.Composition.CompositionObject {
+   public VisualUnorderedCollection ExclusionsFromTargets { get; }
-   public VisualUnorderedCollection Exclusions { get; }
| }

+ public class Windows.UI.Composition.CompositionLinearGradientBrush : Windows.UI.Composition.CompositionGradientBrush {
+   public Vector2 StartPoint { get; set; }
+   public Vector2 EndPoint { get; set; }
+ }

| public class Windows.UI.Composition.CompositionObject {
+   public DispatcherQueue DispatcherQueue { get; }
| }

| public class Windows.UI.Composition.Compositor {
+   public CompositionColorGradientStop CreateColorGradientStop();
+   public CompositionColorGradientStop CreateColorGradientStop( float result, Color offset );
+   public CompositionLinearGradientBrush CreateLinearGradientBrush();
+   public SpringScalarNaturalMotionAnimation CreateSpringScalarAnimation();
+   public SpringVector2NaturalMotionAnimation CreateSpringVector2Animation();
+   public SpringVector3NaturalMotionAnimation CreateSpringVector3Animation();
-   public VisualIslandSite CreateVisualIslandSite();
-   public VisualTreeIsland CreateVisualTreeIsland();
| }

- public class Windows.UI.Composition.ExpressionProperties : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.FramedIslandSite : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.HwndIslandSite : Windows.UI.Composition.CompositionObject;

- public interface Windows.UI.Composition.ICompositionIslandSite;

- public interface Windows.UI.Composition.IVisual3;

+ public class Windows.UI.Composition.InitialValueExpressions : Windows.UI.Composition.CompositionObject {
+   public uint Size { get; }
+   public string Lookup( string returnValue );
+   public bool HasKey( string returnValue );
+   public IMapView<string, string> GetView();
+   public bool Insert( string returnValue, string key );
+   public void Remove( string key );
+   public void Clear();
+   public IIterator<IKeyValuePair<string, string>> First();
+ }

| public class Windows.UI.Composition.LayerVisual : Windows.UI.Composition.ContainerVisual {
+   public CompositionShadow Shadow { get; set; }
| }

+ public class Windows.UI.Composition.NaturalMotionAnimation : Windows.UI.Composition.CompositionAnimation {
+   public AnimationStopBehavior StopBehavior { get; set; }
+   public TimeSpan DelayTime { get; set; }
+   public AnimationDelayBehavior DelayBehavior { get; set; }
+ }

- public class Windows.UI.Composition.PopupIslandSite : Windows.UI.Composition.CompositionObject;

+ public class Windows.UI.Composition.ScalarNaturalMotionAnimation : Windows.UI.Composition.NaturalMotionAnimation {
+   public float InitialVelocity { get; set; }
+   public IReference<float> InitialValue { get; set; }
+   public IReference<float> FinalValue { get; set; }
+ }

+ public class Windows.UI.Composition.SpringScalarNaturalMotionAnimation : Windows.UI.Composition.ScalarNaturalMotionAnimation {
+   public TimeSpan Period { get; set; }
+   public float DampingRatio { get; set; }
+ }

+ public class Windows.UI.Composition.SpringVector2NaturalMotionAnimation : Windows.UI.Composition.Vector2NaturalMotionAnimation {
+   public TimeSpan Period { get; set; }
+   public float DampingRatio { get; set; }
+ }

+ public class Windows.UI.Composition.SpringVector3NaturalMotionAnimation : Windows.UI.Composition.Vector3NaturalMotionAnimation {
+   public TimeSpan Period { get; set; }
+   public float DampingRatio { get; set; }
+ }

+ public class Windows.UI.Composition.Vector2NaturalMotionAnimation : Windows.UI.Composition.NaturalMotionAnimation {
+   public Vector2 InitialVelocity { get; set; }
+   public IReference<Vector2> InitialValue { get; set; }
+   public IReference<Vector2> FinalValue { get; set; }
+ }

+ public class Windows.UI.Composition.Vector3NaturalMotionAnimation : Windows.UI.Composition.NaturalMotionAnimation {
+   public Vector3 InitialVelocity { get; set; }
+   public IReference<Vector3> InitialValue { get; set; }
+   public IReference<Vector3> FinalValue { get; set; }
+ }

| public class Windows.UI.Composition.Visual : Windows.UI.Composition.CompositionObject {
-   public CompositionAnchor CreateAnchor();
| }

- public class Windows.UI.Composition.VisualIslandSite : Windows.UI.Composition.CompositionObject;

- public class Windows.UI.Composition.VisualIslandSiteEventArgs;

- public class Windows.UI.Composition.VisualTreeIsland : Windows.UI.Composition.CompositionIsland;

| public class Windows.UI.Composition.Effects.SceneLightingEffect {
+   public SceneLightingEffectReflectanceModel ReflectanceModel { get; set; }
-   public SceneLightingEffectBrdfType BrdfType { get; set; }
| }

- public enum Windows.UI.Composition.Effects.SceneLightingEffectBrdfType;

+ public enum Windows.UI.Composition.Effects.SceneLightingEffectReflectanceModel {
+   BlinnPhong = 0,
+   PhysicallyBasedBlinnPhong = 1,
+ }

| public class Windows.UI.Composition.Interactions.InteractionTracker : Windows.UI.Composition.CompositionObject {
+   public void ConfigureVector2PositionInertiaModifiers( IIterable<InteractionTrackerVector2InertiaModifier> modifiers );
| }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInertiaNaturalMotion : Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier {
+   public ScalarNaturalMotionAnimation NaturalMotion { get; set; }
+   public ExpressionAnimation Condition { get; set; }
+   public static InteractionTrackerInertiaNaturalMotion Create( Compositor result );
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier : Windows.UI.Composition.CompositionObject {
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaNaturalMotion : Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier {
+   public Vector2NaturalMotionAnimation NaturalMotion { get; set; }
+   public ExpressionAnimation Condition { get; set; }
+   public static InteractionTrackerVector2InertiaNaturalMotion Create( Compositor result );
+ }

| public enum Windows.UI.Core.CoreCursorType {
+   Pin = 14,
+   Person = 15,
| }

| public class Windows.UI.Core.CoreWindow {
+   public CoreWindowActivationMode ActivationMode { get; }
| }

+ public enum Windows.UI.Core.CoreWindowActivationMode {
+   None = 0,
+   Deactivated = 1,
+   ActivatedNotForeground = 2,
+   ActivatedInForeground = 3,
+ }

| public class Windows.UI.Input.RadialControllerConfiguration {
+   public bool IsAppControllerEnabled { get; set; }
+   public RadialController AppController { get; set; }
| }

+ public class Windows.UI.Input.Inking.Core.CoreIncrementalInkStroke {
+   public Rect BoundingRect { get; }
+   public InkDrawingAttributes DrawingAttributes { get; }
+   public Matrix3x2 PointTransform { get; }
+   public CoreIncrementalInkStroke( InkDrawingAttributes drawingAttributes, Matrix3x2 pointTransform );
+   public Rect AppendInkPoints( IIterable<InkPoint> result );
+   public InkStroke CreateInkStroke();
+ }

+ public class Windows.UI.Input.Inking.Core.CoreInkPresenterHost {
+   public ContainerVisual RootVisual { get; set; }
+   public InkPresenter InkPresenter { get; }
+   public CoreInkPresenterHost();
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputGamepadInfo {
+   public double RightTrigger { get; set; }
+   public double RightThumbstickY { get; set; }
+   public double RightThumbstickX { get; set; }
+   public double LeftTrigger { get; set; }
+   public double LeftThumbstickY { get; set; }
+   public double LeftThumbstickX { get; set; }
+   public GamepadButtons Buttons { get; set; }
+   public InjectedInputGamepadInfo( GamepadReading reading );
+   public InjectedInputGamepadInfo();
+ }

| public class Windows.UI.Input.Preview.Injection.InputInjector {
+   public void InitializeGamepadInjection();
+   public void InjectGamepadInput( InjectedInputGamepadInfo input );
+   public void UninitializeGamepadInjection();
+   public static InputInjector TryCreateForAppBroadcastOnly();
| }

| public class Windows.UI.Input.Spatial.SpatialInteractionController {
+   public IAsyncOperation<IRandomAccessStreamWithContentType> TryGetRenderableModelAsync();
| }

| public enum Windows.UI.Input.Spatial.SpatialInteractionSourceHandedness {
+   Both = 3,
| }

| public class Windows.UI.Input.Spatial.SpatialInteractionSourceLocation {
+   public IReference<Vector3> AngularVelocity { get; }
+   public SpatialInteractionSourcePositionQuality PositionQuality { get; }
+   public SpatialPointerInteractionSourcePose SourcePointerPose { get; }
| }

+ public enum Windows.UI.Input.Spatial.SpatialInteractionSourcePositionQuality {
+   Tracked = 0,
+   Inferred = 1,
+   LastKnownPosition = 2,
+ }

| public class Windows.UI.Input.Spatial.SpatialPointerInteractionSourcePose {
+   public Quaternion Orientation { get; }
+   public SpatialInteractionSourcePositionQuality PositionQuality { get; }
| }

+ public class Windows.UI.Shell.AdaptiveCardBuilder {
+   public static IAdaptiveCard CreateAdaptiveCardFromJson( string result );
+ }

+ public interface Windows.UI.Shell.IAdaptiveCard {
+   public string ToJson();
+ }

+ public interface Windows.UI.Shell.IAdaptiveCardBuilderStatics {
+   public IAdaptiveCard CreateAdaptiveCardFromJson( string result );
+ }

+ public class Windows.UI.Shell.TaskbarManager {
+   public bool IsPinningAllowed { get; }
+   public bool IsSupported { get; }
+   public IAsyncOperation<bool> IsCurrentAppPinnedAsync();
+   public IAsyncOperation<bool> IsAppListEntryPinnedAsync( AppListEntry operation );
+   public IAsyncOperation<bool> RequestPinCurrentAppAsync();
+   public IAsyncOperation<bool> RequestPinAppListEntryAsync( AppListEntry operation );
+   public static TaskbarManager GetDefault();
+ }

| public class Windows.UI.StartScreen.SecondaryTileVisualElements {
+   public TileMixedRealityModel MixedRealityModel { get; }
| }

+ public class Windows.UI.StartScreen.TileMixedRealityModel {
+   public Uri Uri { get; set; }
+   public IReference<SpatialBoundingBox> BoundingBox { get; set; }
+ }

- public class Windows.UI.ViewManagement.CoreInputView;

- public class Windows.UI.ViewManagement.CoreInputViewFrameworkOccludingInputViewsChangedEventArgs;

- public class Windows.UI.ViewManagement.CoreInputViewOccludingInputViewsChangedEventArgs;

- public struct Windows.UI.ViewManagement.CoreOccludingInputView;

- public enum Windows.UI.ViewManagement.CoreOccludingInputViewType;

- public class Windows.UI.ViewManagement.CoreOccludingInputViews;

| public class Windows.UI.ViewManagement.ViewModePreferences {
-   public Size CustomMinSize { get; set; }
-   public Size CustomMaxSize { get; set; }
| }

+ public class Windows.UI.ViewManagement.Core.CoreInputView {
+   public IVectorView<CoreInputViewOcclusion> GetCoreInputViewOcclusions();
+   public bool TryShowPrimaryView();
+   public bool TryHidePrimaryView();
+   public static CoreInputView GetForCurrentView();
+   TypedEventHandler<CoreInputView, CoreInputViewOcclusionsChangedEventArgs> OcclusionsChanged;
+ }

+ public class Windows.UI.ViewManagement.Core.CoreInputViewOcclusion {
+   public Rect OccludingRect { get; }
+   public CoreInputViewOcclusionKind OcclusionKind { get; }
+ }

+ public enum Windows.UI.ViewManagement.Core.CoreInputViewOcclusionKind {
+   Docked = 0,
+   Floating = 1,
+   Overlay = 2,
+ }

+ public class Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs {
+   public bool Handled { get; set; }
+   public IVectorView<CoreInputViewOcclusion> Occlusions { get; }
+ }

| public class Windows.UI.WebUI.WebUIApplication {
+   public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync( string operation );
+   public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync( User operation, string user );
| }

+ public class Windows.UI.WebUI.WebUICommandLineActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public User User { get; }
+   public CommandLineActivationOperation Operation { get; }
+   public ActivatedOperation ActivatedOperation { get; }
+ }

- public class Windows.UI.WebUI.WebUIConsoleActivatedEventArgs;

+ public class Windows.UI.WebUI.WebUIStartupTaskActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public User User { get; }
+   public string TaskId { get; }
+ }

| public class Windows.UI.Xaml.FrameworkElement : Windows.UI.Xaml.UIElement {
+   public ElementTheme ActualTheme { get; }
+   public DependencyProperty ActualThemeProperty { get; }
| }

| public enum Windows.UI.Xaml.TextAlignment {
+   Start = 1,
+   End = 2,
| }

| public class Windows.UI.Xaml.UIElement : Windows.UI.Xaml.DependencyObject {
+   public IVector<KeyboardAccelerator> KeyboardAccelerators { get; }
+   public RoutedEvent CharacterReceivedEvent { get; }
+   public void TryInvokeKeyboardAccelerator( ProcessKeyboardAcceleratorEventArgs args );
| }

+ public enum Windows.UI.Xaml.Automation.Peers.AutomationNotificationKind {
+   ItemAdded = 0,
+   ItemRemoved = 1,
+   ActionCompleted = 2,
+   ActionAborted = 3,
+   Other = 4,
+ }

+ public enum Windows.UI.Xaml.Automation.Peers.AutomationNotificationProcessing {
+   ImportantAll = 0,
+   ImportantMostRecent = 1,
+   All = 2,
+   MostRecent = 3,
+   CurrentThenMostRecent = 4,
+ }

| public class Windows.UI.Xaml.Automation.Peers.AutomationPeer : Windows.UI.Xaml.DependencyObject {
+   public void RaiseNotificationEvent( AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, string displayString, string activityId );
| }

+ public enum Windows.UI.Xaml.Controls.CharacterCasing {
+   Normal = 0,
+   Lower = 1,
+   Upper = 2,
+ }

| public class Windows.UI.Xaml.Controls.ComboBox : Windows.UI.Xaml.Controls.Primitives.Selector {
+   public Brush PlaceholderForeground { get; set; }
+   public DependencyProperty PlaceholderForegroundProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.ContentDialog : Windows.UI.Xaml.Controls.ContentControl {
+   public IAsyncOperation<ContentDialogResult> ShowAsync( ContentDialogPlacement returnValue );
| }

+ public enum Windows.UI.Xaml.Controls.ContentDialogPlacement {
+   Popup = 0,
+   InPlace = 1,
+ }

+ public enum Windows.UI.Xaml.Controls.DisabledFormattingAccelerators {
+   None = 0,
+   Bold = 1,
+   Italic = 2,
+   Underline = 4,
+   All = 4294967295,
+ }

| public class Windows.UI.Xaml.Controls.Grid : Windows.UI.Xaml.Controls.Panel {
+   public double RowSpacing { get; set; }
+   public double ColumnSpacing { get; set; }
+   public DependencyProperty ColumnSpacingProperty { get; }
+   public DependencyProperty RowSpacingProperty { get; }
| }

+ public interface Windows.UI.Xaml.Controls.IAdapterAnimationHandler {
+   public void InteractionTrackerAnimation( UIElement refreshVisualizer, UIElement infoProvider, InteractionTracker interactionTracker );
+   public void RefreshRequestedAnimation( UIElement refreshVisualizer, UIElement infoProvider, double executionRatio );
+   public void RefreshCompletedAnimation( UIElement refreshVisualizer, UIElement infoProvider );
+ }

| public interface Windows.UI.Xaml.Controls.IRefreshInfoProvider {
| }

+ public interface Windows.UI.Xaml.Controls.IRefreshInfoProviderAdapter {
+   public IRefreshInfoProvider AdaptFromTree( UIElement value, Size root );
+   public void SetAnimations( UIElement refreshVisualizerAnimatableContainer );
+ }

+ public class Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs {
+ }

| public class Windows.UI.Xaml.Controls.MediaTransportControls : Windows.UI.Xaml.Controls.Control {
+   public bool ShowAndHideAutomatically { get; set; }
+   public bool IsRepeatEnabled { get; set; }
+   public bool IsRepeatButtonVisible { get; set; }
+   public DependencyProperty IsRepeatEnabledProperty { get; }
+   public DependencyProperty ShowAndHideAutomaticallyProperty { get; }
+   public DependencyProperty IsRepeatButtonVisibleProperty { get; }
+   public void Show();
+   public void Hide();
| }

- public class Windows.UI.Xaml.Controls.NavigationMenuItem : Windows.UI.Xaml.Controls.NavigationMenuItemBase;

- public class Windows.UI.Xaml.Controls.NavigationMenuItemAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer;

- public class Windows.UI.Xaml.Controls.NavigationMenuItemBase : Windows.UI.Xaml.Controls.Control;

- public class Windows.UI.Xaml.Controls.NavigationMenuItemBaseObservableCollection;

- public class Windows.UI.Xaml.Controls.NavigationMenuItemSeparator : Windows.UI.Xaml.Controls.NavigationMenuItemBase;

| public class Windows.UI.Xaml.Controls.NavigationView : Windows.UI.Xaml.Controls.ContentControl {
+   public object SelectedItem { get; set; }
+   public DataTemplateSelector ItemTemplateSelector { get; set; }
+   public StyleSelector ItemContainerStyleSelector { get; set; }
+   public AutoSuggestBox AutoSuggestBox { get; set; }
*   public IVector<object> MenuItems { get; }
+   public object SettingsItem { get; }
+   public DependencyProperty AutoSuggestBoxProperty { get; }
+   public DependencyProperty ItemContainerStyleSelectorProperty { get; }
+   public DependencyProperty ItemTemplateSelectorProperty { get; }
+   public DependencyProperty SelectedItemProperty { get; }
+   public DependencyProperty SettingsItemProperty { get; }
+   public object ItemFromContainer( DependencyObject returnValue );
+   public DependencyObject ContainerFromItem( object returnValue );
| }

+ public class Windows.UI.Xaml.Controls.NavigationViewItem : Windows.UI.Xaml.Controls.ListViewItem {
+   public double CompactPaneLength { get; }
+   public NavigationViewItem();
+ }

+ public class Windows.UI.Xaml.Controls.NavigationViewItemAutomationPeer : Windows.UI.Xaml.Automation.Peers.ListViewItemAutomationPeer {
+   public NavigationViewItemAutomationPeer( NavigationViewItem owner );
+ }

+ public class Windows.UI.Xaml.Controls.NavigationViewItemData : Windows.UI.Xaml.DependencyObject {
+   public string Text { get; set; }
+   public NavigationViewItemType ItemType { get; set; }
+   public IconElement Icon { get; set; }
+   public DependencyProperty IconProperty { get; }
+   public DependencyProperty ItemTypeProperty { get; }
+   public DependencyProperty TextProperty { get; }
+   public NavigationViewItemData();
+ }

+ public enum Windows.UI.Xaml.Controls.NavigationViewItemType {
+   Default = 0,
+   Separator = 1,
+   Header = 2,
+ }

+ public class Windows.UI.Xaml.Controls.NavigationViewList : Windows.UI.Xaml.Controls.ListView {
+   public NavigationViewList();
+ }

+ public class Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs {
+   public bool IsContentChanging { get; }
+ }

+ public class Windows.UI.Xaml.Controls.RatingControl : Windows.UI.Xaml.Controls.Control {
+   public IReference<double> Value { get; set; }
+   public IReference<double> PlaceholderValue { get; set; }
+   public int MaxRating { get; set; }
+   public bool IsReadOnly { get; set; }
+   public bool IsClearEnabled { get; set; }
+   public int InitialSetValue { get; set; }
+   public string Caption { get; set; }
+   public DependencyProperty CaptionProperty { get; }
+   public DependencyProperty InitialSetValueProperty { get; }
+   public DependencyProperty IsClearEnabledProperty { get; }
+   public DependencyProperty IsReadOnlyProperty { get; }
+   public DependencyProperty MaxRatingProperty { get; }
+   public DependencyProperty PlaceholderValueProperty { get; }
+   public DependencyProperty ValueProperty { get; }
+   public RatingControl();
+   TypedEventHandler<RatingControl, object> ValueChanged;
+ }

+ public class Windows.UI.Xaml.Controls.RatingControlAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+   public RatingControlAutomationPeer( RatingControl owner );
+ }

- public class Windows.UI.Xaml.Controls.RatingsControl : Windows.UI.Xaml.Controls.Control;

- public class Windows.UI.Xaml.Controls.RatingsControlAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer;

| public class Windows.UI.Xaml.Controls.RefreshContainer : Windows.UI.Xaml.Controls.ContentControl {
+   public RefreshVisualizerLocation RefreshVisualizerLocation { get; set; }
+   public RefreshVisualizer RefreshVisualizer { get; set; }
+   public IRefreshInfoProviderAdapter RefreshInfoProviderAdapter { get; set; }
+   public DependencyProperty RefreshInfoProviderAdapterProperty { get; }
+   public DependencyProperty RefreshVisualizerLocationProperty { get; }
+   public DependencyProperty RefreshVisualizerProperty { get; }
+   public void RefreshRequested();
| }

+ public enum Windows.UI.Xaml.Controls.RefreshVisualizerLocation {
+   Left = 0,
+   Top = 1,
+   Right = 2,
+   Bottom = 3,
+ }

| public class Windows.UI.Xaml.Controls.RichEditBox : Windows.UI.Xaml.Controls.Control {
+   public DisabledFormattingAccelerators DisabledFormattingAccelerators { get; set; }
+   public CharacterCasing CharacterCasing { get; set; }
+   public TextAlignment HorizontalTextAlignment { get; set; }
+   public DependencyProperty DisabledFormattingAcceleratorsProperty { get; }
+   public DependencyProperty HorizontalTextAlignmentProperty { get; }
+   public DependencyProperty CharacterCasingProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.RichTextBlock : Windows.UI.Xaml.FrameworkElement {
+   public TextAlignment HorizontalTextAlignment { get; set; }
+   public bool IsTextTrimmed { get; }
+   public IVector<TextHighlighter> TextHighlighters { get; }
+   public DependencyProperty IsTextTrimmedProperty { get; }
+   public DependencyProperty HorizontalTextAlignmentProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.RichTextBlockOverflow : Windows.UI.Xaml.FrameworkElement {
+   public bool IsTextTrimmed { get; }
+   public DependencyProperty IsTextTrimmedProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.ScrollViewerIRefreshInfoProviderAdapter {
+   public ScrollViewerIRefreshInfoProviderAdapter( RefreshVisualizerLocation refreshVisualizerLocation, IAdapterAnimationHandler animationHandler );
+   public IRefreshInfoProvider Adapt( ScrollViewer value, Size adaptee );
+   public IRefreshInfoProvider AdaptFromTree( UIElement value, Size root );
+   public void SetAnimations( UIElement refreshVisualizerAnimatableContainer );
+ }

| public class Windows.UI.Xaml.Controls.StackPanel : Windows.UI.Xaml.Controls.Panel {
+   public double Spacing { get; set; }
+   public DependencyProperty SpacingProperty { get; }
| }

| public enum Windows.UI.Xaml.Controls.Symbol {
+   GlobalNavigationButton = 59136,
-   GlobalNavButton = 59136,
| }

| public class Windows.UI.Xaml.Controls.TextBlock : Windows.UI.Xaml.FrameworkElement {
+   public TextAlignment HorizontalTextAlignment { get; set; }
+   public bool IsTextTrimmed { get; }
+   public IVector<TextHighlighter> TextHighlighters { get; }
+   public DependencyProperty IsTextTrimmedProperty { get; }
+   public DependencyProperty HorizontalTextAlignmentProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.TextBox : Windows.UI.Xaml.Controls.Control {
+   public Brush PlaceholderForeground { get; set; }
+   public TextAlignment HorizontalTextAlignment { get; set; }
+   public CharacterCasing CharacterCasing { get; set; }
+   public DependencyProperty PlaceholderForegroundProperty { get; }
+   public DependencyProperty HorizontalTextAlignmentProperty { get; }
+   public DependencyProperty CharacterCasingProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs {
+   public bool Cancel { get; set; }
+   public string NewText { get; }
+ }

+ public class Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs {
+   public bool Handled { get; set; }
+ }

+ public class Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs {
+   public bool Handled { get; set; }
+ }

| public class Windows.UI.Xaml.Controls.TreeView : Windows.UI.Xaml.Controls.Control {
+   public TreeViewSelectionMode SelectionMode { get; set; }
+   public IVector<object> SelectedItems { get; }
+   public DependencyProperty SelectionModeProperty { get; }
-   public DependencyProperty RootNodeProperty { get; }
+   public void SelectAll();
| }

+ public enum Windows.UI.Xaml.Controls.TreeViewSelectionMode {
+   None = 0,
+   Single = 1,
+   Multiple = 2,
+ }

| public class Windows.UI.Xaml.Controls.Maps.MapControl : Windows.UI.Xaml.Controls.Control {
+   public IVector<MapLayer> Layers { get; set; }
+   public DependencyProperty LayersProperty { get; }
+   public bool TryGetLocationFromOffset( Point returnValue, ref Geopoint offset );
+   public bool TryGetLocationFromOffset( Point returnValue, AltitudeReferenceSystem offset, ref Geopoint desiredReferenceSystem );
| }

| public class Windows.UI.Xaml.Controls.Maps.MapControlDataHelper : Windows.UI.Xaml.DependencyObject {
+   public static MapControl CreateMapControl( bool returnValue );
| }

| public class Windows.UI.Xaml.Controls.Maps.MapElement : Windows.UI.Xaml.DependencyObject {
+   public object Tag { get; set; }
+   public string MapStyleSheetEntryState { get; set; }
+   public string MapStyleSheetEntry { get; set; }
+   public DependencyProperty MapStyleSheetEntryProperty { get; }
+   public DependencyProperty MapStyleSheetEntryStateProperty { get; }
+   public DependencyProperty TagProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.Maps.MapElement3D : Windows.UI.Xaml.Controls.Maps.MapElement {
+   public Vector3 Scale { get; set; }
+   public double Roll { get; set; }
+   public double Pitch { get; set; }
+   public MapModel3D Model { get; set; }
+   public Geopoint Location { get; set; }
+   public double Heading { get; set; }
+   public DependencyProperty HeadingProperty { get; }
+   public DependencyProperty LocationProperty { get; }
+   public DependencyProperty PitchProperty { get; }
+   public DependencyProperty RollProperty { get; }
+   public DependencyProperty ScaleProperty { get; }
+   public MapElement3D();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapElementsLayer : Windows.UI.Xaml.Controls.Maps.MapLayer {
+   public IVector<MapElement> MapElements { get; set; }
+   public DependencyProperty MapElementsProperty { get; }
+   public MapElementsLayer();
+   TypedEventHandler<MapElementsLayer, MapElementsLayerContextRequestedEventArgs> MapContextRequested;
+   TypedEventHandler<MapElementsLayer, MapElementsLayerClickEventArgs> MapElementClick;
+   TypedEventHandler<MapElementsLayer, MapElementsLayerPointerEnteredEventArgs> MapElementPointerEntered;
+   TypedEventHandler<MapElementsLayer, MapElementsLayerPointerExitedEventArgs> MapElementPointerExited;
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs {
+   public Geopoint Location { get; }
+   public IVector<MapElement> MapElements { get; }
+   public Point Position { get; }
+   public MapElementsLayerClickEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs {
+   public Geopoint Location { get; }
+   public IVectorView<MapElement> MapElements { get; }
+   public Point Position { get; }
+   public MapElementsLayerContextRequestedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs {
+   public Geopoint Location { get; }
+   public MapElement MapElement { get; }
+   public Point Position { get; }
+   public MapElementsLayerPointerEnteredEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs {
+   public Geopoint Location { get; }
+   public MapElement MapElement { get; }
+   public Point Position { get; }
+   public MapElementsLayerPointerExitedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapLayer : Windows.UI.Xaml.DependencyObject {
+   public int ZIndex { get; set; }
+   public bool Visible { get; set; }
+   public int MapTabIndex { get; set; }
+   public DependencyProperty MapTabIndexProperty { get; }
+   public DependencyProperty VisibleProperty { get; }
+   public DependencyProperty ZIndexProperty { get; }
+   public MapLayer();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapModel3D : Windows.UI.Xaml.DependencyObject {
+   public MapModel3D();
+   public static IAsyncOperation<MapModel3D> CreateFrom3MFAsync( IRandomAccessStreamReference returnValue );
+   public static IAsyncOperation<MapModel3D> CreateFrom3MFAsync( IRandomAccessStreamReference returnValue, MapModel3DShadingOption source );
+ }

+ public enum Windows.UI.Xaml.Controls.Maps.MapModel3DShadingOption {
+   Default = 0,
+   Flat = 1,
+   Smooth = 2,
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapStyleSheetEntries {
+   public string AdminDistrict { get; }
+   public string AdminDistrictCapital { get; }
+   public string Airport { get; }
+   public string Area { get; }
+   public string ArterialRoad { get; }
+   public string Building { get; }
+   public string Business { get; }
+   public string Capital { get; }
+   public string Cemetery { get; }
+   public string Continent { get; }
+   public string ControlledAccessHighway { get; }
+   public string CountryRegion { get; }
+   public string CountryRegionCapital { get; }
+   public string District { get; }
+   public string DrivingRoute { get; }
+   public string Education { get; }
+   public string EducationBuilding { get; }
+   public string FoodPoint { get; }
+   public string Forest { get; }
+   public string GolfCourse { get; }
+   public string HighSpeedRamp { get; }
+   public string Highway { get; }
+   public string IndigenousPeoplesReserve { get; }
+   public string Island { get; }
+   public string MajorRoad { get; }
+   public string Medical { get; }
+   public string MedicalBuilding { get; }
+   public string Military { get; }
+   public string NaturalPoint { get; }
+   public string Nautical { get; }
+   public string Neighborhood { get; }
+   public string Park { get; }
+   public string Peak { get; }
+   public string PlayingField { get; }
+   public string Point { get; }
+   public string PointOfInterest { get; }
+   public string Political { get; }
+   public string PopulatedPlace { get; }
+   public string Railway { get; }
+   public string Ramp { get; }
+   public string Reserve { get; }
+   public string River { get; }
+   public string Road { get; }
+   public string RoadExit { get; }
+   public string RoadShield { get; }
+   public string RouteLine { get; }
+   public string Runway { get; }
+   public string Sand { get; }
+   public string ShoppingCenter { get; }
+   public string Stadium { get; }
+   public string Street { get; }
+   public string Structure { get; }
+   public string TollRoad { get; }
+   public string Trail { get; }
+   public string Transit { get; }
+   public string TransitBuilding { get; }
+   public string Transportation { get; }
+   public string UnpavedStreet { get; }
+   public string Vegetation { get; }
+   public string VolcanicPeak { get; }
+   public string WalkingRoute { get; }
+   public string Water { get; }
+   public string WaterPoint { get; }
+   public string WaterRoute { get; }
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapStyleSheetEntryStates {
+   public string Default { get; }
+   public string Disabled { get; }
+   public string Hover { get; }
+   public string Selected { get; }
+ }

| public class Windows.UI.Xaml.Controls.Primitives.FlyoutBase : Windows.UI.Xaml.DependencyObject {
+   public void TryInvokeKeyboardAccelerator( ProcessKeyboardAcceleratorEventArgs args );
| }

| public class Windows.UI.Xaml.Documents.Block : Windows.UI.Xaml.Documents.TextElement {
+   public TextAlignment HorizontalTextAlignment { get; set; }
+   public DependencyProperty HorizontalTextAlignmentProperty { get; }
| }

+ public class Windows.UI.Xaml.Documents.TextHighlighter {
+   public Brush Foreground { get; set; }
+   public Brush Background { get; set; }
+   public IVector<TextRange> Ranges { get; }
+   public DependencyProperty BackgroundProperty { get; }
+   public DependencyProperty ForegroundProperty { get; }
+   public TextHighlighter();
+ }

+ public class Windows.UI.Xaml.Documents.TextHighlighterBase : Windows.UI.Xaml.DependencyObject {
+ }

+ public struct Windows.UI.Xaml.Documents.TextRange {
+   public int StartIndex;
+   public int Length;
+ }

+ public class Windows.UI.Xaml.Hosting.DesignerAppManager {
+   public string AppUserModelId { get; }
+   public DesignerAppManager( string appUserModelId );
+   public IAsyncOperation<DesignerAppView> CreateNewViewAsync( DesignerAppViewState returnValue, Size initialViewState );
+   public IAsyncAction LoadObjectIntoAppAsync( string returnValue, Guid dllName, string classId );
+   public ulong DuplicateHandleIntoApp( ulong returnValue, bool handle );
+   public void Close();
+   TypedEventHandler<DesignerAppManager, ProcessExitedEventArgs> ProcessExited;
+ }

+ public class Windows.UI.Xaml.Hosting.DesignerAppView {
+   public string AppUserModelId { get; }
+   public int ApplicationViewId { get; }
+   public Size ViewSize { get; }
+   public DesignerAppViewState ViewState { get; }
+   public IAsyncAction UpdateViewAsync( DesignerAppViewState returnValue, Size viewState );
+   public void Close();
+ }

+ public enum Windows.UI.Xaml.Hosting.DesignerAppViewState {
+   Visible = 0,
+   Hidden = 1,
+ }

+ public class Windows.UI.Xaml.Hosting.ProcessExitedEventArgs {
+   public uint ExitCode { get; }
+ }

+ public class Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public bool Handled { get; set; }
+   public char Character { get; }
+   public CorePhysicalKeyStatus KeyStatus { get; }
+ }

+ public class Windows.UI.Xaml.Input.KeyboardAccelerator : Windows.UI.Xaml.DependencyObject {
+   public DependencyObject ScopeOwner { get; set; }
+   public VirtualKeyModifiers Modifiers { get; set; }
+   public VirtualKey Key { get; set; }
+   public bool IsEnabled { get; set; }
+   public DependencyProperty IsEnabledProperty { get; }
+   public DependencyProperty KeyProperty { get; }
+   public DependencyProperty ModifiersProperty { get; }
+   public DependencyProperty ScopeOwnerProperty { get; }
+   public KeyboardAccelerator();
+   TypedEventHandler<KeyboardAccelerator, KeyboardAcceleratorInvokedEventArgs> Invoked;
+ }

+ public class Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs {
+   public bool Handled { get; set; }
+   public DependencyObject Element { get; }
+ }

+ public class Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs {
+   public bool Handled { get; set; }
+   public VirtualKey Key { get; }
+   public VirtualKeyModifiers Modifiers { get; }
+ }

| public enum Windows.Web.WebErrorStatus {
+   InsufficientRangeSupport = 22,
+   MissingContentLengthSupport = 23,
| }