10586 vs 14379

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

 new file: 14379_Windows.WinMD
 old file: 10586_Windows.WinMD

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

+ public class Windows.ApplicationModel.EnteredBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public interface Windows.ApplicationModel.IEnteredBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public interface Windows.ApplicationModel.ILeavingBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.LeavingBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

| public class Windows.ApplicationModel.Package {
+   public bool IsOptional { get; }
+   public PackageSignatureKind SignatureKind { get; }
+   public IAsyncOperation<bool> VerifyContentIntegrityAsync();
| }

+ public class Windows.ApplicationModel.PackageCatalog {
+   public static PackageCatalog OpenForCurrentPackage();
+   public static PackageCatalog OpenForCurrentUser();
+   TypedEventHandler<PackageCatalog, PackageInstallingEventArgs> PackageInstalling;
+   TypedEventHandler<PackageCatalog, PackageStagingEventArgs> PackageStaging;
+   TypedEventHandler<PackageCatalog, PackageStatusChangedEventArgs> PackageStatusChanged;
+   TypedEventHandler<PackageCatalog, PackageUninstallingEventArgs> PackageUninstalling;
+   TypedEventHandler<PackageCatalog, PackageUpdatingEventArgs> PackageUpdating;
+ }

+ public class Windows.ApplicationModel.PackageInstallingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public Package Package { get; }
+   public double Progress { get; }
+ }

+ public enum Windows.ApplicationModel.PackageSignatureKind {
+   None = 0,
+   Developer = 1,
+   Enterprise = 2,
+   Store = 3,
+   System = 4,
+ }

+ public class Windows.ApplicationModel.PackageStagingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public Package Package { get; }
+   public double Progress { get; }
+ }

+ public class Windows.ApplicationModel.PackageStatusChangedEventArgs {
+   public Package Package { get; }
+ }

+ public class Windows.ApplicationModel.PackageUninstallingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public Package Package { get; }
+   public double Progress { get; }
+ }

+ public class Windows.ApplicationModel.PackageUpdatingEventArgs {
+   public Guid ActivityId { get; }
+   public HResult ErrorCode { get; }
+   public bool IsComplete { get; }
+   public double Progress { get; }
+   public Package SourcePackage { get; }
+   public Package TargetPackage { get; }
+ }

| public enum Windows.ApplicationModel.Activation.ActivationKind {
+   UserDataAccountsProvider = 1014,
+   FilePickerExperience = 1015,
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderAddAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderRemoveAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderReplaceAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.AppointmentsProviderShowTimeFrameActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs {
+   public IBackgroundTaskInstance TaskInstance { get; }
+ }

| public class Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.DeviceActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.DevicePairingActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.DialReceiverActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileOpenPickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FileSavePickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.FolderPickerContinuationEventArgs {
+   public User User { get; }
| }

+ public interface Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser {
+   public User User { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs {
+   public IBackgroundTaskInstance TaskInstance { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs2 {
+   public TileActivatedInfo TileActivatedInfo { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IUserDataAccountProviderActivatedEventArgs {
+   public IUserDataAccountProviderOperation Operation { get; }
+ }

| public class Windows.ApplicationModel.Activation.LaunchActivatedEventArgs {
+   public User User { get; }
+   public TileActivatedInfo TileActivatedInfo { get; }
| }

| public class Windows.ApplicationModel.Activation.LockScreenActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.ProtocolActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.ProtocolForResultsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.RestrictedLaunchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.SearchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.ApplicationModel.Activation.TileActivatedInfo {
+   public IVectorView<ShownTileNotification> RecentlyShownNotifications { get; }
+ }

| public class Windows.ApplicationModel.Activation.ToastNotificationActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.ApplicationModel.Activation.UserDataAccountProviderActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public IUserDataAccountProviderOperation Operation { get; }
+ }

| public class Windows.ApplicationModel.Activation.VoiceCommandActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.ApplicationModel.Activation.WebAccountProviderActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.ApplicationModel.AppExtensions.AppExtension {
+   public AppInfo AppInfo { get; }
+   public string Description { get; }
+   public string DisplayName { get; }
+   public string Id { get; }
+   public Package Package { get; }
+   public IAsyncOperation<IPropertySet> GetExtensionPropertiesAsync();
+   public IAsyncOperation<StorageFolder> GetPublicFolderAsync();
+ }

+ public class Windows.ApplicationModel.AppExtensions.AppExtensionCatalog {
+   public IAsyncOperation<IVectorView<AppExtension>> FindAllAsync();
+   public IAsyncOperation<bool> RequestRemovePackageAsync( string operation );
+   public static AppExtensionCatalog Open( string value );
+   TypedEventHandler<AppExtensionCatalog, AppExtensionPackageInstalledEventArgs> PackageInstalled;
+   TypedEventHandler<AppExtensionCatalog, AppExtensionPackageStatusChangedEventArgs> PackageStatusChanged;
+   TypedEventHandler<AppExtensionCatalog, AppExtensionPackageUninstallingEventArgs> PackageUninstalling;
+   TypedEventHandler<AppExtensionCatalog, AppExtensionPackageUpdatedEventArgs> PackageUpdated;
+   TypedEventHandler<AppExtensionCatalog, AppExtensionPackageUpdatingEventArgs> PackageUpdating;
+ }

+ public class Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs {
+   public string AppExtensionName { get; }
+   public IVectorView<AppExtension> Extensions { get; }
+   public Package Package { get; }
+ }

+ public class Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs {
+   public string AppExtensionName { get; }
+   public Package Package { get; }
+ }

+ public class Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs {
+   public string AppExtensionName { get; }
+   public Package Package { get; }
+ }

+ public class Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs {
+   public string AppExtensionName { get; }
+   public IVectorView<AppExtension> Extensions { get; }
+   public Package Package { get; }
+ }

+ public class Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs {
+   public string AppExtensionName { get; }
+   public Package Package { get; }
+ }

| public class Windows.ApplicationModel.AppService.AppServiceConnection {
+   public User User { get; set; }
+   public IAsyncOperation<AppServiceConnectionStatus> OpenRemoteAsync( RemoteSystemConnectionRequest operation );
| }

| public enum Windows.ApplicationModel.AppService.AppServiceConnectionStatus {
+   RemoteSystemUnavailable = 5,
+   RemoteSystemNotSupportedByApp = 6,
+   NotAuthorized = 7,
| }

| public enum Windows.ApplicationModel.AppService.AppServiceResponseStatus {
+   RemoteSystemUnavailable = 4,
+   MessageSizeTooLarge = 5,
| }

| public class Windows.ApplicationModel.AppService.AppServiceTriggerDetails {
+   public bool IsRemoteSystemConnection { get; }
| }

| public class Windows.ApplicationModel.Appointments.AppointmentCalendar {
+   public IAsyncAction RegisterSyncManagerAsync();
| }

| public enum Windows.ApplicationModel.Appointments.AppointmentCalendarOtherAppReadAccess {
+   None = 3,
| }

| public enum Windows.ApplicationModel.Appointments.AppointmentCalendarOtherAppWriteAccess {
+   Limited = 2,
| }

| public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager {
*   public AppointmentCalendarSyncStatus Status { get; set; }
*   public DateTime LastSuccessfulSyncTime { get; set; }
*   public DateTime LastAttemptedSyncTime { get; set; }
| }

| public class Windows.ApplicationModel.Appointments.AppointmentManager {
+   public static AppointmentManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<string> ShowAddAppointmentAsync( Appointment result, Rect appointment );
+   public IAsyncOperation<string> ShowAddAppointmentAsync( Appointment result, Rect appointment, Placement selection );
+   public IAsyncOperation<string> ShowReplaceAppointmentAsync( string result, Appointment appointmentId, Rect appointment );
+   public IAsyncOperation<string> ShowReplaceAppointmentAsync( string result, Appointment appointmentId, Rect appointment, Placement selection );
+   public IAsyncOperation<string> ShowReplaceAppointmentAsync( string result, Appointment appointmentId, Rect appointment, Placement selection, DateTime preferredPlacement );
+   public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string result, Rect appointmentId );
+   public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string result, Rect appointmentId, Placement selection );
+   public IAsyncOperation<bool> ShowRemoveAppointmentAsync( string result, Rect appointmentId, Placement selection, DateTime preferredPlacement );
+   public IAsyncAction ShowTimeFrameAsync( DateTime result, TimeSpan timeToShow );
+   public IAsyncAction ShowAppointmentDetailsAsync( string result );
+   public IAsyncAction ShowAppointmentDetailsAsync( string result, DateTime appointmentId );
+   public IAsyncOperation<string> ShowEditNewAppointmentAsync( Appointment result );
+   public IAsyncOperation<AppointmentStore> RequestStoreAsync( AppointmentStoreAccessType result );
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest {
+   public string AppointmentCalendarLocalId { get; }
+   public string AppointmentLocalId { get; }
+   public IReference<DateTime> AppointmentOriginalStartTime { get; }
+   public string Comment { get; }
+   public bool NotifyInvitees { get; }
+   public string Subject { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs {
+   public AppointmentCalendarCancelMeetingRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest {
+   public Appointment Appointment { get; }
+   public string AppointmentCalendarLocalId { get; }
+   public IVectorView<string> ChangedProperties { get; }
+   public bool NotifyInvitees { get; }
+   public IAsyncAction ReportCompletedAsync( Appointment result );
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs {
+   public AppointmentCalendarCreateOrUpdateAppointmentRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest {
+   public string AppointmentCalendarLocalId { get; }
+   public string AppointmentLocalId { get; }
+   public IReference<DateTime> AppointmentOriginalStartTime { get; }
+   public string Comment { get; }
+   public string ForwardHeader { get; }
+   public IVectorView<AppointmentInvitee> Invitees { get; }
+   public string Subject { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs {
+   public AppointmentCalendarForwardMeetingRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest {
+   public string AppointmentCalendarLocalId { get; }
+   public string AppointmentLocalId { get; }
+   public IReference<DateTime> AppointmentOriginalStartTime { get; }
+   public string Comment { get; }
+   public TimeSpan NewDuration { get; }
+   public DateTime NewStartTime { get; }
+   public string Subject { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs {
+   public AppointmentCalendarProposeNewTimeForMeetingRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequest {
+   public string AppointmentCalendarLocalId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs {
+   public AppointmentCalendarSyncManagerSyncRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest {
+   public string AppointmentCalendarLocalId { get; }
+   public string AppointmentLocalId { get; }
+   public IReference<DateTime> AppointmentOriginalStartTime { get; }
+   public string Comment { get; }
+   public AppointmentParticipantResponse Response { get; }
+   public bool SendUpdate { get; }
+   public string Subject { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs {
+   public AppointmentCalendarUpdateMeetingResponseRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection {
+   public void Start();
+   TypedEventHandler<AppointmentDataProviderConnection, AppointmentCalendarCancelMeetingRequestEventArgs> CancelMeetingRequested;
+   TypedEventHandler<AppointmentDataProviderConnection, AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs> CreateOrUpdateAppointmentRequested;
+   TypedEventHandler<AppointmentDataProviderConnection, AppointmentCalendarForwardMeetingRequestEventArgs> ForwardMeetingRequested;
+   TypedEventHandler<AppointmentDataProviderConnection, AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs> ProposeNewTimeForMeetingRequested;
+   TypedEventHandler<AppointmentDataProviderConnection, AppointmentCalendarSyncManagerSyncRequestEventArgs> SyncRequested;
+   TypedEventHandler<AppointmentDataProviderConnection, AppointmentCalendarUpdateMeetingResponseRequestEventArgs> UpdateMeetingResponseRequested;
+ }

+ public class Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderTriggerDetails {
+   public AppointmentDataProviderConnection Connection { get; }
+ }

| public enum Windows.ApplicationModel.Background.BackgroundAccessStatus {
+   AlwaysAllowed = 4,
+   AllowedSubjectToSystemPolicy = 5,
+   DeniedBySystemPolicy = 6,
+   DeniedByUser = 7,
| }

+ public interface Windows.ApplicationModel.Background.IBackgroundTaskInstance4 {
+   public User User { get; }
+ }

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

| public class Windows.ApplicationModel.Background.SocketActivityTrigger {
+   public bool IsWakeFromLowPowerSupported { get; }
| }

| public enum Windows.ApplicationModel.Background.SystemTriggerType {
+   DefaultSignInAccountChange = 15,
| }

+ public class Windows.ApplicationModel.Background.UserNotificationChangedTrigger {
+   public UserNotificationChangedTrigger( NotificationKinds notificationKinds );
+ }

| public class Windows.ApplicationModel.Calls.PhoneCallHistoryManager {
+   public static PhoneCallHistoryManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Calls.PhoneCallHistoryManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<PhoneCallHistoryStore> RequestStoreAsync( PhoneCallHistoryStoreAccessType result );
+ }

| public class Windows.ApplicationModel.Calls.Provider.PhoneCallOrigin {
+   public StorageFile DisplayPicture { get; set; }
| }

| public class Windows.ApplicationModel.Calls.Provider.PhoneCallOriginManager {
+   public static IAsyncOperation<bool> RequestSetAsActiveCallOriginAppAsync();
| }

| public class Windows.ApplicationModel.Chat.ChatConversation {
+   public ChatItemKind ItemKind { get; }
| }

| public class Windows.ApplicationModel.Chat.ChatMessage {
+   public ChatItemKind ItemKind { get; }
+   public string SyncId { get; set; }
| }

| public class Windows.ApplicationModel.Chat.ChatMessageManager {
+   public static IAsyncOperation<ChatSyncManager> RequestSyncManagerAsync();
| }

| public class Windows.ApplicationModel.Chat.ChatMessageStore {
+   public IAsyncOperation<ChatMessage> GetMessageBySyncIdAsync( string result );
| }

| public enum Windows.ApplicationModel.Chat.ChatMessageValidationStatus {
+   ValidWithLargeMessage = 11,
+   VoiceRoamingRestriction = 12,
+   DataRoamingRestriction = 13,
| }

+ public enum Windows.ApplicationModel.Chat.ChatRestoreHistorySpan {
+   LastMonth = 0,
+   LastYear = 1,
+   AnyTime = 2,
+ }

+ public class Windows.ApplicationModel.Chat.ChatSyncConfiguration {
+   public ChatRestoreHistorySpan RestoreHistorySpan { get; set; }
+   public bool IsSyncEnabled { get; set; }
+ }

+ public class Windows.ApplicationModel.Chat.ChatSyncManager {
+   public ChatSyncConfiguration Configuration { get; }
+   public IAsyncAction AssociateAccountAsync( WebAccount result );
+   public IAsyncAction UnassociateAccountAsync();
+   public bool IsAccountAssociated( WebAccount result );
+   public void StartSync();
+   public IAsyncAction SetConfigurationAsync( ChatSyncConfiguration result );
+ }

| public class Windows.ApplicationModel.CommunicationBlocking.CommunicationBlockingAppManager {
+   public static IAsyncOperation<bool> RequestSetAsActiveBlockingAppAsync();
| }

| public class Windows.ApplicationModel.Contacts.AggregateContactManager {
+   public IAsyncAction SetRemoteIdentificationInformationAsync( string result, string contactListId, string remoteSourceId );
| }

| public enum Windows.ApplicationModel.Contacts.ContactCardTabKind {
+   OrganizationalHierarchy = 5,
| }

| public class Windows.ApplicationModel.Contacts.ContactList {
*   public bool SupportsServerSearch { get; set; }
+   public ContactListSyncConstraints SyncConstraints { get; }
+   public IAsyncAction RegisterSyncManagerAsync();
| }

| public enum Windows.ApplicationModel.Contacts.ContactListOtherAppReadAccess {
+   None = 3,
| }

+ public class Windows.ApplicationModel.Contacts.ContactListSyncConstraints {
+   public bool CanSyncDescriptions { get; set; }
+   public IReference<int> MaxCompanyPhoneNumbers { get; set; }
+   public IReference<int> MaxChildRelationships { get; set; }
+   public IReference<int> MaxBusinessFaxPhoneNumbers { get; set; }
+   public IReference<int> MaxBirthdayDates { get; set; }
+   public IReference<int> MaxAssistantPhoneNumbers { get; set; }
+   public IReference<int> MaxOtherAddresses { get; set; }
+   public IReference<int> MaxAnniversaryDates { get; set; }
+   public IReference<int> MaxHomeAddresses { get; set; }
+   public IReference<int> MaxOtherDates { get; set; }
+   public IReference<int> MaxMobilePhoneNumbers { get; set; }
+   public IReference<int> MaxJobInfo { get; set; }
+   public IReference<int> MaxHomePhoneNumbers { get; set; }
+   public IReference<int> MaxHomeFaxPhoneNumbers { get; set; }
+   public IReference<int> MaxOtherEmailAddresses { get; set; }
+   public IReference<int> MaxPersonalEmailAddresses { get; set; }
+   public IReference<int> MaxPartnerRelationships { get; set; }
+   public IReference<int> MaxParentRelationships { get; set; }
+   public IReference<int> MaxPagerPhoneNumbers { get; set; }
+   public IReference<int> MaxOtherRelationships { get; set; }
+   public IReference<int> MaxOtherPhoneNumbers { get; set; }
+   public IReference<int> MaxRadioPhoneNumbers { get; set; }
+   public IReference<int> MaxWorkPhoneNumbers { get; set; }
+   public IReference<int> MaxWorkEmailAddresses { get; set; }
+   public IReference<int> MaxWorkAddresses { get; set; }
+   public IReference<int> MaxWebsites { get; set; }
+   public IReference<int> MaxSpouseRelationships { get; set; }
+   public IReference<int> MaxSiblingRelationships { get; set; }
+ }

| public class Windows.ApplicationModel.Contacts.ContactListSyncManager {
*   public ContactListSyncStatus Status { get; set; }
*   public DateTime LastSuccessfulSyncTime { get; set; }
*   public DateTime LastAttemptedSyncTime { get; set; }
| }

| public class Windows.ApplicationModel.Contacts.ContactManager {
+   public static ContactManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Contacts.ContactManagerForUser {
+   public ContactNameOrder SystemSortOrder { get; set; }
+   public ContactNameOrder SystemDisplayNameOrder { get; set; }
+   public User User { get; }
+   public IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact result );
+   public IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact result, uint contact );
+   public IAsyncOperation<Contact> ConvertVCardToContactAsync( IRandomAccessStreamReference result );
+   public IAsyncOperation<ContactStore> RequestStoreAsync( ContactStoreAccessType result );
+   public IAsyncOperation<ContactAnnotationStore> RequestAnnotationStoreAsync( ContactAnnotationStoreAccessType result );
+ }

+ public class Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection {
+   public void Start();
+   TypedEventHandler<ContactDataProviderConnection, ContactListServerSearchReadBatchRequestEventArgs> ServerSearchReadBatchRequested;
+   TypedEventHandler<ContactDataProviderConnection, ContactListSyncManagerSyncRequestEventArgs> SyncRequested;
+ }

+ public class Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderTriggerDetails {
+   public ContactDataProviderConnection Connection { get; }
+ }

+ public class Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequest {
+   public string ContactListId { get; }
+   public ContactQueryOptions Options { get; }
+   public string SessionId { get; }
+   public uint SuggestedBatchSize { get; }
+   public IAsyncAction SaveContactAsync( Contact result );
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync( ContactBatchStatus result );
+ }

+ public class Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs {
+   public ContactListServerSearchReadBatchRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequest {
+   public string ContactListId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs {
+   public ContactListSyncManagerSyncRequest Request { get; }
+   public Deferral GetDeferral();
+ }

| public class Windows.ApplicationModel.Core.CoreApplication {
+   public static void EnablePrelaunch( bool value );
| }

| public class Windows.ApplicationModel.DataTransfer.DataTransferManager {
+   public static bool IsSupported();
| }

| public class Windows.ApplicationModel.Email.EmailMailbox {
+   public IAsyncAction RegisterSyncManagerAsync();
| }

| public class Windows.ApplicationModel.Email.EmailMailboxCapabilities {
*   public bool CanSmartSend { get; set; }
*   public bool CanUpdateMeetingResponses { get; set; }
*   public bool CanServerSearchMailbox { get; set; }
*   public bool CanServerSearchFolders { get; set; }
*   public bool CanForwardMeetings { get; set; }
*   public bool CanProposeNewTimeForMeetings { get; set; }
*   public bool CanGetAndSetInternalAutoReplies { get; set; }
*   public bool CanGetAndSetExternalAutoReplies { get; set; }
*   public bool CanValidateCertificates { get; set; }
*   public bool CanResolveRecipients { get; set; }
*   public bool CanMoveFolder { get; set; }
*   public bool CanEmptyFolder { get; set; }
*   public bool CanDeleteFolder { get; set; }
*   public bool CanCreateFolder { get; set; }
| }

| public enum Windows.ApplicationModel.Email.EmailMailboxOtherAppReadAccess {
+   None = 2,
| }

| public class Windows.ApplicationModel.Email.EmailMailboxPolicies {
*   public IReference<EmailMailboxSmimeSigningAlgorithm> RequiredSmimeSigningAlgorithm { get; set; }
*   public IReference<EmailMailboxSmimeEncryptionAlgorithm> RequiredSmimeEncryptionAlgorithm { get; set; }
*   public EmailMailboxAllowedSmimeEncryptionAlgorithmNegotiation AllowedSmimeEncryptionAlgorithmNegotiation { get; set; }
*   public bool AllowSmimeSoftCertificates { get; set; }
*   public bool MustSignSmimeMessages { get; set; }
*   public bool MustEncryptSmimeMessages { get; set; }
| }

| public class Windows.ApplicationModel.Email.EmailMailboxSyncManager {
*   public EmailMailboxSyncStatus Status { get; set; }
*   public DateTime LastSuccessfulSyncTime { get; set; }
*   public DateTime LastAttemptedSyncTime { get; set; }
| }

| public class Windows.ApplicationModel.Email.EmailManager {
+   public static EmailManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.Email.EmailManagerForUser {
+   public User User { get; }
+   public IAsyncAction ShowComposeNewEmailAsync( EmailMessage result );
+   public IAsyncOperation<EmailStore> RequestStoreAsync( EmailStoreAccessType result );
+ }

| public class Windows.ApplicationModel.Email.EmailRecipientResolutionResult {
*   public EmailRecipientResolutionStatus Status { get; set; }
+   public EmailRecipientResolutionResult();
+   public void SetPublicKeys( IIterable<Certificate> value );
| }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection {
+   public void Start();
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxCreateFolderRequestEventArgs> CreateFolderRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxDeleteFolderRequestEventArgs> DeleteFolderRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxDownloadAttachmentRequestEventArgs> DownloadAttachmentRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxDownloadMessageRequestEventArgs> DownloadMessageRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxEmptyFolderRequestEventArgs> EmptyFolderRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxForwardMeetingRequestEventArgs> ForwardMeetingRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxGetAutoReplySettingsRequestEventArgs> GetAutoReplySettingsRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxSyncManagerSyncRequestEventArgs> MailboxSyncRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxMoveFolderRequestEventArgs> MoveFolderRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxProposeNewTimeForMeetingRequestEventArgs> ProposeNewTimeForMeetingRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxResolveRecipientsRequestEventArgs> ResolveRecipientsRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxServerSearchReadBatchRequestEventArgs> ServerSearchReadBatchRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxSetAutoReplySettingsRequestEventArgs> SetAutoReplySettingsRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxUpdateMeetingResponseRequestEventArgs> UpdateMeetingResponseRequested;
+   TypedEventHandler<EmailDataProviderConnection, EmailMailboxValidateCertificatesRequestEventArgs> ValidateCertificatesRequested;
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailDataProviderTriggerDetails {
+   public EmailDataProviderConnection Connection { get; }
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequest {
+   public string EmailMailboxId { get; }
+   public string Name { get; }
+   public string ParentFolderId { get; }
+   public IAsyncAction ReportCompletedAsync( EmailFolder result );
+   public IAsyncAction ReportFailedAsync( EmailMailboxCreateFolderStatus result );
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs {
+   public EmailMailboxCreateFolderRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequest {
+   public string EmailFolderId { get; }
+   public string EmailMailboxId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync( EmailMailboxDeleteFolderStatus result );
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs {
+   public EmailMailboxDeleteFolderRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequest {
+   public string EmailAttachmentId { get; }
+   public string EmailMailboxId { get; }
+   public string EmailMessageId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs {
+   public EmailMailboxDownloadAttachmentRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequest {
+   public string EmailMailboxId { get; }
+   public string EmailMessageId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs {
+   public EmailMailboxDownloadMessageRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequest {
+   public string EmailFolderId { get; }
+   public string EmailMailboxId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync( EmailMailboxEmptyFolderStatus result );
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs {
+   public EmailMailboxEmptyFolderRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequest {
+   public string Comment { get; }
+   public string EmailMailboxId { get; }
+   public string EmailMessageId { get; }
+   public string ForwardHeader { get; }
+   public EmailMessageBodyKind ForwardHeaderType { get; }
+   public IVectorView<EmailRecipient> Recipients { get; }
+   public string Subject { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs {
+   public EmailMailboxForwardMeetingRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequest {
+   public string EmailMailboxId { get; }
+   public EmailMailboxAutoReplyMessageResponseKind RequestedFormat { get; }
+   public IAsyncAction ReportCompletedAsync( EmailMailboxAutoReplySettings result );
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs {
+   public EmailMailboxGetAutoReplySettingsRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequest {
+   public string EmailFolderId { get; }
+   public string EmailMailboxId { get; }
+   public string NewFolderName { get; }
+   public string NewParentFolderId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs {
+   public EmailMailboxMoveFolderRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequest {
+   public string Comment { get; }
+   public string EmailMailboxId { get; }
+   public string EmailMessageId { get; }
+   public TimeSpan NewDuration { get; }
+   public DateTime NewStartTime { get; }
+   public string Subject { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs {
+   public EmailMailboxProposeNewTimeForMeetingRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequest {
+   public string EmailMailboxId { get; }
+   public IVectorView<string> Recipients { get; }
+   public IAsyncAction ReportCompletedAsync( IIterable<EmailRecipientResolutionResult> result );
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs {
+   public EmailMailboxResolveRecipientsRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequest {
+   public string EmailFolderId { get; }
+   public string EmailMailboxId { get; }
+   public EmailQueryOptions Options { get; }
+   public string SessionId { get; }
+   public uint SuggestedBatchSize { get; }
+   public IAsyncAction SaveMessageAsync( EmailMessage result );
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync( EmailBatchStatus result );
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs {
+   public EmailMailboxServerSearchReadBatchRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequest {
+   public EmailMailboxAutoReplySettings AutoReplySettings { get; }
+   public string EmailMailboxId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs {
+   public EmailMailboxSetAutoReplySettingsRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequest {
+   public string EmailMailboxId { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs {
+   public EmailMailboxSyncManagerSyncRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequest {
+   public string Comment { get; }
+   public string EmailMailboxId { get; }
+   public string EmailMessageId { get; }
+   public EmailMeetingResponseType Response { get; }
+   public bool SendUpdate { get; }
+   public string Subject { get; }
+   public IAsyncAction ReportCompletedAsync();
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs {
+   public EmailMailboxUpdateMeetingResponseRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequest {
+   public IVectorView<Certificate> Certificates { get; }
+   public string EmailMailboxId { get; }
+   public IAsyncAction ReportCompletedAsync( IIterable<EmailCertificateValidationStatus> result );
+   public IAsyncAction ReportFailedAsync();
+ }

+ public class Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs {
+   public EmailMailboxValidateCertificatesRequest Request { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Store.LicenseManagement.LicenseManager {
+   public static IAsyncAction AddLicenseAsync( IBuffer action );
+   public static IAsyncOperation<LicenseSatisfactionResult> GetSatisfactionInfosAsync( IIterable<string> operation, IIterable<string> contentIds );
+ }

+ public class Windows.ApplicationModel.Store.LicenseManagement.LicenseSatisfactionInfo {
+   public bool IsSatisfied { get; }
+   public bool SatisfiedByDevice { get; }
+   public bool SatisfiedByInstallMedia { get; }
+   public bool SatisfiedByOpenLicense { get; }
+   public bool SatisfiedByPass { get; }
+   public bool SatisfiedBySignedInUser { get; }
+   public bool SatisfiedByTrial { get; }
+ }

+ public class Windows.ApplicationModel.Store.LicenseManagement.LicenseSatisfactionResult {
+   public HResult ExtendedError { get; }
+   public IMapView<string, LicenseSatisfactionInfo> LicenseSatisfactionInfos { get; }
+ }

| public class Windows.ApplicationModel.Store.Preview.StoreConfiguration {
+   public static bool HasStoreWebAccount();
+   public static bool HasStoreWebAccountForUser( User value );
+   public static IAsyncOperation<IRandomAccessStreamReference> GetStoreLogDataAsync( StoreLogOptions operation );
+   public static void SetStoreWebAccountIdForUser( User user, string webAccountId );
+   public static bool IsStoreWebAccountIdForUser( User value, string user );
+   public static IReference<uint> GetPurchasePromptingPolicyForUser( User value );
+   public static void SetPurchasePromptingPolicyForUser( User user, IReference<uint> value );
| }

+ public enum Windows.ApplicationModel.Store.Preview.StoreLogOptions {
+   None = 0,
+   TryElevate = 1,
+ }

| public enum Windows.ApplicationModel.Store.Preview.StoreSystemFeature {
+   Memory4GB = 24,
+   Memory6GB = 25,
+   Memory8GB = 26,
+   Memory12GB = 27,
+   Memory16GB = 28,
+   Memory20GB = 29,
+   VideoMemory2GB = 30,
+   VideoMemory4GB = 31,
+   VideoMemory6GB = 32,
+   VideoMemory1GB = 33,
| }

| public class Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager {
+   public IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync( string operation, string productId, string catalogId, string flightId, bool clientId, bool repair, string forceUseOfNonRemovableStorage, PackageVolume correlationVector );
+   public IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync( User operation, string user, string productId, string catalogId, string flightId, bool clientId, bool repair, string forceUseOfNonRemovableStorage, PackageVolume correlationVector );
+   public IAsyncOperation<AppInstallItem> UpdateAppByPackageFamilyNameForUserAsync( User operation, string user, string packageFamilyName );
+   public IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync( User operation, string user, string productId, string skuId, string catalogId );
+   public IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync( User operation, string user );
+   public IAsyncOperation<bool> GetIsAppAllowedToInstallForUserAsync( User operation, string user, string productId, string skuId, string catalogId );
+   public IAsyncOperation<bool> GetIsApplicableForUserAsync( User operation, string user, string productId );
+   public void MoveToFrontOfDownloadQueue( string productId, string correlationVector );
| }

| public class Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallStatus {
+   public bool ReadyForLaunch { get; }
+   public User User { get; }
| }

| public class Windows.ApplicationModel.UserDataAccounts.UserDataAccount {
+   public string DisplayName { get; set; }
+   public IVector<string> ExplictReadAccessPackageFamilyNames { get; }
| }

| public class Windows.ApplicationModel.UserDataAccounts.UserDataAccountManager {
+   public static UserDataAccountManagerForUser GetForUser( User result );
| }

+ public class Windows.ApplicationModel.UserDataAccounts.UserDataAccountManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<UserDataAccountStore> RequestStoreAsync( UserDataAccountStoreAccessType result );
+ }

| public enum Windows.ApplicationModel.UserDataAccounts.UserDataAccountOtherAppReadAccess {
+   None = 2,
| }

| public class Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore {
+   public IAsyncOperation<UserDataAccount> CreateAccountAsync( string result, string userDisplayName );
| }

+ public class Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs {
+   public Deferral GetDeferral();
+ }

+ public interface Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation {
+   public UserDataAccountProviderOperationKind Kind { get; }
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountPartnerAccountInfo {
+   public UserDataAccountProviderPartnerAccountKind AccountKind { get; }
+   public string DisplayName { get; }
+   public uint Priority { get; }
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderAddAccountOperation {
+   public UserDataAccountContentKinds ContentKinds { get; }
+   public IVectorView<UserDataAccountPartnerAccountInfo> PartnerAccountInfos { get; }
+   public UserDataAccountProviderOperationKind Kind { get; }
+   public void ReportCompleted( string userDataAccountId );
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderOperationKind {
+   AddAccount = 0,
+   Settings = 1,
+   ResolveErrors = 2,
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderPartnerAccountKind {
+   Exchange = 0,
+   PopOrImap = 1,
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderResolveErrorsOperation {
+   public UserDataAccountProviderOperationKind Kind { get; }
+   public string UserDataAccountId { get; }
+   public void ReportCompleted();
+ }

+ public class Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountProviderSettingsOperation {
+   public UserDataAccountProviderOperationKind Kind { get; }
+   public string UserDataAccountId { get; }
+   public void ReportCompleted();
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountAuthenticationType {
+   Basic = 0,
+   OAuth = 1,
+   SingleSignOn = 2,
+ }

| public class Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration {
+   public DeviceAccountIconId AccountIconId { get; set; }
+   public Uri CalDavServerUrl { get; set; }
+   public bool CalDavRequiresSsl { get; set; }
+   public bool AutoSelectAuthenticationCertificate { get; set; }
+   public DeviceAccountAuthenticationType AuthenticationType { get; set; }
+   public string AuthenticationCertificateId { get; set; }
+   public bool IsOutgoingServerAuthenticationEnabled { get; set; }
+   public bool IsClientAuthenticationCertificateRequired { get; set; }
+   public PasswordCredential IncomingServerCredential { get; set; }
+   public bool IsOutgoingServerAuthenticationRequired { get; set; }
+   public DeviceAccountSyncScheduleKind CardDavSyncScheduleKind { get; set; }
+   public bool AlwaysDownloadFullMessage { get; set; }
+   public Uri CardDavServerUrl { get; set; }
+   public bool CardDavRequiresSsl { get; set; }
+   public DeviceAccountSyncScheduleKind CalDavSyncScheduleKind { get; set; }
+   public string IncomingServerCertificateHash { get; set; }
+   public bool WasOutgoingServerCertificateHashConfirmed { get; set; }
+   public bool WasModifiedByUser { get; set; }
+   public DeviceAccountSyncScheduleKind SyncScheduleKind { get; set; }
+   public string SsoAccountId { get; set; }
+   public bool WasIncomingServerCertificateHashConfirmed { get; set; }
+   public string OAuthRefreshToken { get; set; }
+   public bool IsExternallyManaged { get; set; }
+   public DeviceAccountMailAgeFilter MailAgeFilter { get; set; }
+   public bool IsSyncScheduleManagedBySystem { get; set; }
+   public string OutgoingServerCertificateHash { get; set; }
+   public PasswordCredential OutgoingServerCredential { get; set; }
+   public bool DoesPolicyAllowMailSync { get; }
+   public bool IsSsoAuthenticationSupported { get; }
| }

+ public enum Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountIconId {
+   Exchange = 0,
+   Msa = 1,
+   Outlook = 2,
+   Generic = 3,
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountMailAgeFilter {
+   All = 0,
+   Last1Day = 1,
+   Last3Days = 2,
+   Last7Days = 3,
+   Last14Days = 4,
+   Last30Days = 5,
+   Last90Days = 6,
+ }

+ public enum Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountSyncScheduleKind {
+   Manual = 0,
+   Every15Minutes = 1,
+   Every30Minutes = 2,
+   Every60Minutes = 3,
+   Every2Hours = 4,
+   Daily = 5,
+   AsItemsArrive = 6,
+ }

| public class Windows.ApplicationModel.UserDataAccounts.SystemAccess.UserDataAccountSystemAccessManager {
+   public static IAsyncAction SuppressLocalAccountWithAccountAsync( string result );
+   public static IAsyncOperation<string> CreateDeviceAccountAsync( DeviceAccountConfiguration result );
+   public static IAsyncAction DeleteDeviceAccountAsync( string result );
+   public static IAsyncOperation<DeviceAccountConfiguration> GetDeviceAccountConfigurationAsync( string result );
| }

+ public class Windows.Data.Text.TextPhoneme {
+   public string DisplayText { get; }
+   public string ReadingText { get; }
+ }

| public class Windows.Data.Text.TextReverseConversionGenerator {
+   public IAsyncOperation<IVectorView<TextPhoneme>> GetPhonemesAsync( string result );
| }

+ public struct Windows.Devices.DevicesLowLevelContract {
+ }

+ public interface Windows.Devices.ILowLevelDevicesAggregateProvider {
+   public IAdcControllerProvider AdcControllerProvider { get; }
+   public IGpioControllerProvider GpioControllerProvider { get; }
+   public II2cControllerProvider I2cControllerProvider { get; }
+   public IPwmControllerProvider PwmControllerProvider { get; }
+   public ISpiControllerProvider SpiControllerProvider { get; }
+ }

+ public class Windows.Devices.LowLevelDevicesAggregateProvider {
+   public IAdcControllerProvider AdcControllerProvider { get; }
+   public IGpioControllerProvider GpioControllerProvider { get; }
+   public II2cControllerProvider I2cControllerProvider { get; }
+   public IPwmControllerProvider PwmControllerProvider { get; }
+   public ISpiControllerProvider SpiControllerProvider { get; }
+   public LowLevelDevicesAggregateProvider( IAdcControllerProvider adc, IPwmControllerProvider pwm, IGpioControllerProvider gpio, II2cControllerProvider i2c, ISpiControllerProvider spi );
+ }

+ public class Windows.Devices.LowLevelDevicesController {
+   public ILowLevelDevicesAggregateProvider DefaultProvider { get; set; }
+ }

+ public class Windows.Devices.Adc.AdcChannel {
+   public AdcController Controller { get; }
+   public int ReadValue();
+   public double ReadRatio();
+   public void Close();
+ }

+ public enum Windows.Devices.Adc.AdcChannelMode {
+   SingleEnded = 0,
+   Differential = 1,
+ }

+ public class Windows.Devices.Adc.AdcController {
+   public AdcChannelMode ChannelMode { get; set; }
+   public int ChannelCount { get; }
+   public int MaxValue { get; }
+   public int MinValue { get; }
+   public int ResolutionInBits { get; }
+   public bool IsChannelModeSupported( AdcChannelMode result );
+   public AdcChannel OpenChannel( int result );
+   public static IAsyncOperation<AdcController> GetDefaultAsync();
+   public static IAsyncOperation<IVectorView<AdcController>> GetControllersAsync( IAdcProvider operation );
+ }

+ public interface Windows.Devices.Adc.Provider.IAdcControllerProvider {
+   public int ChannelCount { get; }
+   public ProviderAdcChannelMode ChannelMode { get; set; }
+   public int MaxValue { get; }
+   public int MinValue { get; }
+   public int ResolutionInBits { get; }
+   public bool IsChannelModeSupported( ProviderAdcChannelMode result );
+   public void AcquireChannel( int channel );
+   public void ReleaseChannel( int channel );
+   public int ReadValue( int result );
+ }

+ public interface Windows.Devices.Adc.Provider.IAdcProvider {
+   public IVectorView<IAdcControllerProvider> GetControllers();
+ }

+ public enum Windows.Devices.Adc.Provider.ProviderAdcChannelMode {
+   SingleEnded = 0,
+   Differential = 1,
+ }

| public enum Windows.Devices.AllJoyn.AllJoynAuthenticationMechanism {
+   EcdheSpeke = 6,
| }

| public class Windows.Devices.AllJoyn.AllJoynBusAttachment {
+   public IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync( AllJoynServiceInfo operation );
+   public IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync( AllJoynServiceInfo operation, Language serviceInfo );
+   public static AllJoynBusAttachment GetDefault();
+   public static DeviceWatcher GetWatcher( IIterable<string> deviceWatcher );
| }

+ public class Windows.Devices.AllJoyn.AllJoynBusObject {
+   public AllJoynBusAttachment BusAttachment { get; }
+   public AllJoynSession Session { get; }
+   public AllJoynBusObject( string objectPath );
+   public AllJoynBusObject( string objectPath, AllJoynBusAttachment busAttachment );
+   public AllJoynBusObject();
+   public void Start();
+   public void Stop();
+   public void AddProducer( IAllJoynProducer producer );
+   TypedEventHandler<AllJoynBusObject, AllJoynBusObjectStoppedEventArgs> Stopped;
+ }

+ public class Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs {
+   public int Status { get; }
+   public AllJoynBusObjectStoppedEventArgs( int status );
+ }

| public class Windows.Devices.AllJoyn.AllJoynServiceInfo {
+   public static IAsyncOperation<AllJoynServiceInfo> FromIdAsync( string operation );
| }

+ public class Windows.Devices.AllJoyn.AllJoynSession {
+   public int Id { get; }
+   public int Status { get; }
+   public IAsyncOperation<int> RemoveMemberAsync( string operation );
+   public static IAsyncOperation<AllJoynSession> GetFromServiceInfoAsync( AllJoynServiceInfo operation );
+   public static IAsyncOperation<AllJoynSession> GetFromServiceInfoAsync( AllJoynServiceInfo operation, AllJoynBusAttachment serviceInfo );
+   TypedEventHandler<AllJoynSession, AllJoynSessionLostEventArgs> Lost;
+   TypedEventHandler<AllJoynSession, AllJoynSessionMemberAddedEventArgs> MemberAdded;
+   TypedEventHandler<AllJoynSession, AllJoynSessionMemberRemovedEventArgs> MemberRemoved;
+ }

+ public class Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs {
+   public AllJoynSession Session { get; }
+   public AllJoynSessionJoinedEventArgs( AllJoynSession session );
+ }

+ public interface Windows.Devices.AllJoyn.IAllJoynProducer {
+   public void SetBusObject( AllJoynBusObject busObject );
+ }

| public class Windows.Devices.Bluetooth.BluetoothDevice {
+   public DeviceAccessInformation DeviceAccessInformation { get; }
+   public IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
+   public IAsyncOperation<RfcommDeviceServicesResult> GetRfcommServicesAsync();
+   public IAsyncOperation<RfcommDeviceServicesResult> GetRfcommServicesAsync( BluetoothCacheMode operation );
+   public IAsyncOperation<RfcommDeviceServicesResult> GetRfcommServicesForIdAsync( RfcommServiceId operation );
+   public IAsyncOperation<RfcommDeviceServicesResult> GetRfcommServicesForIdAsync( RfcommServiceId operation, BluetoothCacheMode serviceId );
| }

| public enum Windows.Devices.Bluetooth.BluetoothError {
+   ConsentRequired = 8,
| }

| public class Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService {
+   public DeviceAccessInformation DeviceAccessInformation { get; }
+   public IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
+   public static string GetDeviceSelectorForBluetoothDevice( BluetoothDevice selector );
+   public static string GetDeviceSelectorForBluetoothDevice( BluetoothDevice selector, BluetoothCacheMode bluetoothDevice );
+   public static string GetDeviceSelectorForBluetoothDeviceAndServiceId( BluetoothDevice selector, RfcommServiceId bluetoothDevice );
+   public static string GetDeviceSelectorForBluetoothDeviceAndServiceId( BluetoothDevice selector, RfcommServiceId bluetoothDevice, BluetoothCacheMode serviceId );
| }

+ public class Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult {
+   public BluetoothError Error { get; }
+   public IVectorView<RfcommDeviceService> Services { get; }
+ }

| public class Windows.Devices.Enumeration.DeviceAccessChangedEventArgs {
+   public string Id { get; }
| }

| public class Windows.Devices.Enumeration.EnclosureLocation {
+   public uint RotationAngleInDegreesClockwise { get; }
| }

| public class Windows.Devices.Geolocation.Geolocator {
+   public IReference<BasicGeoposition> DefaultGeoposition { get; set; }
+   public bool IsDefaultGeopositionRecommended { get; }
+   public void AllowFallbackToConsentlessPositions();
| }

| public enum Windows.Devices.Geolocation.PositionSource {
+   Default = 5,
+   Obfuscated = 6,
| }

+ public class Windows.Devices.Gpio.GpioController {
+   public int PinCount { get; }
+   public GpioPin OpenPin( int pin );
+   public GpioPin OpenPin( int pin, GpioSharingMode pinNumber );
+   public bool TryOpenPin( int succeeded, GpioSharingMode pinNumber, ref GpioPin sharingMode, ref GpioOpenStatus pin );
+   public static IAsyncOperation<IVectorView<GpioController>> GetControllersAsync( IGpioProvider operation );
+   public static IAsyncOperation<GpioController> GetDefaultAsync();
+   public static GpioController GetDefault();
+ }

+ public enum Windows.Devices.Gpio.GpioOpenStatus {
+   PinOpened = 0,
+   PinUnavailable = 1,
+   SharingViolation = 2,
+ }

+ public class Windows.Devices.Gpio.GpioPin {
+   public TimeSpan DebounceTimeout { get; set; }
+   public int PinNumber { get; }
+   public GpioSharingMode SharingMode { get; }
+   public bool IsDriveModeSupported( GpioPinDriveMode supported );
+   public GpioPinDriveMode GetDriveMode();
+   public void SetDriveMode( GpioPinDriveMode value );
+   public void Write( GpioPinValue value );
+   public GpioPinValue Read();
+   public void Close();
+   TypedEventHandler<GpioPin, GpioPinValueChangedEventArgs> ValueChanged;
+ }

+ public enum Windows.Devices.Gpio.GpioPinDriveMode {
+   Input = 0,
+   Output = 1,
+   InputPullUp = 2,
+   InputPullDown = 3,
+   OutputOpenDrain = 4,
+   OutputOpenDrainPullUp = 5,
+   OutputOpenSource = 6,
+   OutputOpenSourcePullDown = 7,
+ }

+ public enum Windows.Devices.Gpio.GpioPinEdge {
+   FallingEdge = 0,
+   RisingEdge = 1,
+ }

+ public enum Windows.Devices.Gpio.GpioPinValue {
+   Low = 0,
+   High = 1,
+ }

+ public class Windows.Devices.Gpio.GpioPinValueChangedEventArgs {
+   public GpioPinEdge Edge { get; }
+ }

+ public enum Windows.Devices.Gpio.GpioSharingMode {
+   Exclusive = 0,
+   SharedReadOnly = 1,
+ }

+ public class Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs {
+   public ProviderGpioPinEdge Edge { get; }
+   public GpioPinProviderValueChangedEventArgs( ProviderGpioPinEdge edge );
+ }

+ public interface Windows.Devices.Gpio.Provider.IGpioControllerProvider {
+   public int PinCount { get; }
+   public IGpioPinProvider OpenPinProvider( int gpioPinProvider, ProviderGpioSharingMode pin );
+ }

+ public interface Windows.Devices.Gpio.Provider.IGpioPinProvider {
+   public TimeSpan DebounceTimeout { get; set; }
+   public int PinNumber { get; }
+   public ProviderGpioSharingMode SharingMode { get; }
+   public bool IsDriveModeSupported( ProviderGpioPinDriveMode supported );
+   public ProviderGpioPinDriveMode GetDriveMode();
+   public void SetDriveMode( ProviderGpioPinDriveMode value );
+   public void Write( ProviderGpioPinValue value );
+   public ProviderGpioPinValue Read();
+   TypedEventHandler<IGpioPinProvider, GpioPinProviderValueChangedEventArgs> ValueChanged;
+ }

+ public interface Windows.Devices.Gpio.Provider.IGpioProvider {
+   public IVectorView<IGpioControllerProvider> GetControllers();
+ }

+ public enum Windows.Devices.Gpio.Provider.ProviderGpioPinDriveMode {
+   Input = 0,
+   Output = 1,
+   InputPullUp = 2,
+   InputPullDown = 3,
+   OutputOpenDrain = 4,
+   OutputOpenDrainPullUp = 5,
+   OutputOpenSource = 6,
+   OutputOpenSourcePullDown = 7,
+ }

+ public enum Windows.Devices.Gpio.Provider.ProviderGpioPinEdge {
+   FallingEdge = 0,
+   RisingEdge = 1,
+ }

+ public enum Windows.Devices.Gpio.Provider.ProviderGpioPinValue {
+   Low = 0,
+   High = 1,
+ }

+ public enum Windows.Devices.Gpio.Provider.ProviderGpioSharingMode {
+   Exclusive = 0,
+   SharedReadOnly = 1,
+ }

| public class Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription {
+   public bool IsAbsolute { get; }
| }

+ public enum Windows.Devices.I2c.I2cBusSpeed {
+   StandardMode = 0,
+   FastMode = 1,
+ }

+ public class Windows.Devices.I2c.I2cConnectionSettings {
+   public int SlaveAddress { get; set; }
+   public I2cSharingMode SharingMode { get; set; }
+   public I2cBusSpeed BusSpeed { get; set; }
+   public I2cConnectionSettings( int slaveAddress );
+ }

+ public class Windows.Devices.I2c.I2cController {
+   public I2cDevice GetDevice( I2cConnectionSettings device );
+   public static IAsyncOperation<IVectorView<I2cController>> GetControllersAsync( II2cProvider operation );
+   public static IAsyncOperation<I2cController> GetDefaultAsync();
+ }

+ public class Windows.Devices.I2c.I2cDevice {
+   public I2cConnectionSettings ConnectionSettings { get; }
+   public string DeviceId { get; }
+   public void Write( byte[] buffer );
+   public I2cTransferResult WritePartial( byte[] result );
+   public void Read( byte[] buffer );
+   public I2cTransferResult ReadPartial( byte[] result );
+   public void WriteRead( byte[] writeBuffer, byte[] readBuffer );
+   public I2cTransferResult WriteReadPartial( byte[] result, byte[] writeBuffer );
+   public void Close();
+   public static string GetDeviceSelector();
+   public static string GetDeviceSelector( string value );
+   public static IAsyncOperation<I2cDevice> FromIdAsync( string operation, I2cConnectionSettings deviceId );
+ }

+ public enum Windows.Devices.I2c.I2cSharingMode {
+   Exclusive = 0,
+   Shared = 1,
+ }

+ public struct Windows.Devices.I2c.I2cTransferResult {
+   public I2cTransferStatus Status;
+   public uint BytesTransferred;
+ }

+ public enum Windows.Devices.I2c.I2cTransferStatus {
+   FullTransfer = 0,
+   PartialTransfer = 1,
+   SlaveAddressNotAcknowledged = 2,
+ }

+ public interface Windows.Devices.I2c.II2cDeviceStatics {
+   public string GetDeviceSelector();
+   public string GetDeviceSelector( string value );
+   public IAsyncOperation<I2cDevice> FromIdAsync( string operation, I2cConnectionSettings deviceId );
+ }

+ public interface Windows.Devices.I2c.Provider.II2cControllerProvider {
+   public II2cDeviceProvider GetDeviceProvider( ProviderI2cConnectionSettings device );
+ }

+ public interface Windows.Devices.I2c.Provider.II2cDeviceProvider {
+   public string DeviceId { get; }
+   public void Write( byte[] buffer );
+   public ProviderI2cTransferResult WritePartial( byte[] result );
+   public void Read( byte[] buffer );
+   public ProviderI2cTransferResult ReadPartial( byte[] result );
+   public void WriteRead( byte[] writeBuffer, byte[] readBuffer );
+   public ProviderI2cTransferResult WriteReadPartial( byte[] result, byte[] writeBuffer );
+ }

+ public interface Windows.Devices.I2c.Provider.II2cProvider {
+   public IAsyncOperation<IVectorView<II2cControllerProvider>> GetControllersAsync();
+ }

+ public enum Windows.Devices.I2c.Provider.ProviderI2cBusSpeed {
+   StandardMode = 0,
+   FastMode = 1,
+ }

+ public class Windows.Devices.I2c.Provider.ProviderI2cConnectionSettings {
+   public int SlaveAddress { get; set; }
+   public ProviderI2cSharingMode SharingMode { get; set; }
+   public ProviderI2cBusSpeed BusSpeed { get; set; }
+ }

+ public enum Windows.Devices.I2c.Provider.ProviderI2cSharingMode {
+   Exclusive = 0,
+   Shared = 1,
+ }

+ public struct Windows.Devices.I2c.Provider.ProviderI2cTransferResult {
+   public ProviderI2cTransferStatus Status;
+   public uint BytesTransferred;
+ }

+ public enum Windows.Devices.I2c.Provider.ProviderI2cTransferStatus {
+   FullTransfer = 0,
+   PartialTransfer = 1,
+   SlaveAddressNotAcknowledged = 2,
+ }

| public enum Windows.Devices.Midi.MidiMessageType {
+   EndSystemExclusive = 247,
| }

| public class Windows.Devices.PointOfService.BarcodeScanner {
+   public string VideoDeviceId { get; }
| }

+ public class Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs {
+   public string NewDeviceId { get; }
+ }

+ public class Windows.Devices.Pwm.PwmController {
+   public double ActualFrequency { get; }
+   public double MaxFrequency { get; }
+   public double MinFrequency { get; }
+   public int PinCount { get; }
+   public double SetDesiredFrequency( double value );
+   public PwmPin OpenPin( int pin );
+   public static IAsyncOperation<PwmController> GetDefaultAsync();
+   public static IAsyncOperation<IVectorView<PwmController>> GetControllersAsync( IPwmProvider operation );
+ }

+ public class Windows.Devices.Pwm.PwmPin {
+   public PwmPulsePolarity Polarity { get; set; }
+   public PwmController Controller { get; }
+   public bool IsStarted { get; }
+   public double GetActiveDutyCyclePercentage();
+   public void SetActiveDutyCyclePercentage( double dutyCyclePercentage );
+   public void Start();
+   public void Stop();
+   public void Close();
+ }

+ public enum Windows.Devices.Pwm.PwmPulsePolarity {
+   ActiveHigh = 0,
+   ActiveLow = 1,
+ }

+ public interface Windows.Devices.Pwm.Provider.IPwmControllerProvider {
+   public double ActualFrequency { get; }
+   public double MaxFrequency { get; }
+   public double MinFrequency { get; }
+   public int PinCount { get; }
+   public double SetDesiredFrequency( double value );
+   public void AcquirePin( int pin );
+   public void ReleasePin( int pin );
+   public void EnablePin( int pin );
+   public void DisablePin( int pin );
+   public void SetPulseParameters( int pin, double dutyCycle, bool invertPolarity );
+ }

+ public interface Windows.Devices.Pwm.Provider.IPwmProvider {
+   public IVectorView<IPwmControllerProvider> GetControllers();
+ }

| public class Windows.Devices.Sensors.Accelerometer {
+   public AccelerometerReadingType ReadingType { get; }
+   public static Accelerometer GetDefault( AccelerometerReadingType result );
| }

+ public enum Windows.Devices.Sensors.AccelerometerReadingType {
+   Standard = 0,
+   Linear = 1,
+   Gravity = 2,
+ }

| public class Windows.Devices.Sensors.Inclinometer {
+   public static Inclinometer GetDefault( SensorReadingType result );
| }

| public class Windows.Devices.Sensors.OrientationSensor {
+   public static OrientationSensor GetDefault( SensorReadingType result );
+   public static OrientationSensor GetDefault( SensorReadingType result, SensorOptimizationGoal sensorReadingType );
| }

+ public enum Windows.Devices.Sensors.SensorOptimizationGoal {
+   Precision = 0,
+   PowerEfficiency = 1,
+ }

| public class Windows.Devices.SmartCards.SmartCardAutomaticResponseApdu {
+   public bool AllowWhenCryptogramGeneratorNotPrepared { get; set; }
| }

| public class Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyInfo {
+   public string OperationalRequirements { get; }
| }

| public enum Windows.Devices.SmartCards.SmartCardEmulationType {
+   EmbeddedSE = 2,
| }

| public enum Windows.Devices.SmartCards.SmartCardReaderKind {
+   EmbeddedSE = 5,
| }

| public enum Windows.Devices.SmartCards.SmartCardTriggerType {
+   ReaderCardAdded = 5,
| }

+ public interface Windows.Devices.Spi.ISpiDeviceStatics {
+   public string GetDeviceSelector();
+   public string GetDeviceSelector( string value );
+   public SpiBusInfo GetBusInfo( string busInfo );
+   public IAsyncOperation<SpiDevice> FromIdAsync( string operation, SpiConnectionSettings busId );
+ }

+ public class Windows.Devices.Spi.SpiBusInfo {
+   public int ChipSelectLineCount { get; }
+   public int MaxClockFrequency { get; }
+   public int MinClockFrequency { get; }
+   public IVectorView<int> SupportedDataBitLengths { get; }
+ }

+ public class Windows.Devices.Spi.SpiConnectionSettings {
+   public SpiSharingMode SharingMode { get; set; }
+   public SpiMode Mode { get; set; }
+   public int DataBitLength { get; set; }
+   public int ClockFrequency { get; set; }
+   public int ChipSelectLine { get; set; }
+   public SpiConnectionSettings( int chipSelectLine );
+ }

+ public class Windows.Devices.Spi.SpiController {
+   public SpiDevice GetDevice( SpiConnectionSettings device );
+   public static IAsyncOperation<SpiController> GetDefaultAsync();
+   public static IAsyncOperation<IVectorView<SpiController>> GetControllersAsync( ISpiProvider operation );
+ }

+ public class Windows.Devices.Spi.SpiDevice {
+   public SpiConnectionSettings ConnectionSettings { get; }
+   public string DeviceId { get; }
+   public void Write( byte[] buffer );
+   public void Read( byte[] buffer );
+   public void TransferSequential( byte[] writeBuffer, byte[] readBuffer );
+   public void TransferFullDuplex( byte[] writeBuffer, byte[] readBuffer );
+   public void Close();
+   public static string GetDeviceSelector();
+   public static string GetDeviceSelector( string value );
+   public static SpiBusInfo GetBusInfo( string busInfo );
+   public static IAsyncOperation<SpiDevice> FromIdAsync( string operation, SpiConnectionSettings busId );
+ }

+ public enum Windows.Devices.Spi.SpiMode {
+   Mode0 = 0,
+   Mode1 = 1,
+   Mode2 = 2,
+   Mode3 = 3,
+ }

+ public enum Windows.Devices.Spi.SpiSharingMode {
+   Exclusive = 0,
+   Shared = 1,
+ }

+ public interface Windows.Devices.Spi.Provider.ISpiControllerProvider {
+   public ISpiDeviceProvider GetDeviceProvider( ProviderSpiConnectionSettings result );
+ }

+ public interface Windows.Devices.Spi.Provider.ISpiDeviceProvider {
+   public ProviderSpiConnectionSettings ConnectionSettings { get; }
+   public string DeviceId { get; }
+   public void Write( byte[] buffer );
+   public void Read( byte[] buffer );
+   public void TransferSequential( byte[] writeBuffer, byte[] readBuffer );
+   public void TransferFullDuplex( byte[] writeBuffer, byte[] readBuffer );
+ }

+ public interface Windows.Devices.Spi.Provider.ISpiProvider {
+   public IAsyncOperation<IVectorView<ISpiControllerProvider>> GetControllersAsync();
+ }

+ public class Windows.Devices.Spi.Provider.ProviderSpiConnectionSettings {
+   public ProviderSpiSharingMode SharingMode { get; set; }
+   public ProviderSpiMode Mode { get; set; }
+   public int DataBitLength { get; set; }
+   public int ClockFrequency { get; set; }
+   public int ChipSelectLine { get; set; }
+   public ProviderSpiConnectionSettings( int chipSelectLine );
+ }

+ public enum Windows.Devices.Spi.Provider.ProviderSpiMode {
+   Mode0 = 0,
+   Mode1 = 1,
+   Mode2 = 2,
+   Mode3 = 3,
+ }

+ public enum Windows.Devices.Spi.Provider.ProviderSpiSharingMode {
+   Exclusive = 0,
+   Shared = 1,
+ }

| public enum Windows.Devices.WiFi.WiFiPhyKind {
+   Dmg = 9,
| }

+ public class Windows.Foundation.Metadata.CreateFromStringAttribute : System.Attribute {
+   public string MethodName;
+   public CreateFromStringAttribute();
+ }

+ public class Windows.Gaming.Input.ArcadeStick {
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public IVectorView<ArcadeStick> ArcadeSticks { get; }
+   public GameControllerButtonLabel GetButtonLabel( ArcadeStickButtons value );
+   public ArcadeStickReading GetCurrentReading();
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<ArcadeStick> ArcadeStickAdded;
+   EventHandler<ArcadeStick> ArcadeStickRemoved;
+ }

+ public enum Windows.Gaming.Input.ArcadeStickButtons {
+   None = 0,
+   StickUp = 1,
+   StickDown = 2,
+   StickLeft = 4,
+   StickRight = 8,
+   Action1 = 16,
+   Action2 = 32,
+   Action3 = 64,
+   Action4 = 128,
+   Action5 = 256,
+   Action6 = 512,
+   Special1 = 1024,
+   Special2 = 2048,
+ }

+ public struct Windows.Gaming.Input.ArcadeStickReading {
+   public ulong Timestamp;
+   public ArcadeStickButtons Buttons;
+ }

+ public enum Windows.Gaming.Input.GameControllerButtonLabel {
+   None = 0,
+   XboxBack = 1,
+   XboxStart = 2,
+   XboxMenu = 3,
+   XboxView = 4,
+   XboxUp = 5,
+   XboxDown = 6,
+   XboxLeft = 7,
+   XboxRight = 8,
+   XboxA = 9,
+   XboxB = 10,
+   XboxX = 11,
+   XboxY = 12,
+   XboxLeftBumper = 13,
+   XboxLeftTrigger = 14,
+   XboxLeftStickButton = 15,
+   XboxRightBumper = 16,
+   XboxRightTrigger = 17,
+   XboxRightStickButton = 18,
+   XboxPaddle1 = 19,
+   XboxPaddle2 = 20,
+   XboxPaddle3 = 21,
+   XboxPaddle4 = 22,
+   Mode = 23,
+   Select = 24,
+   Menu = 25,
+   View = 26,
+   Back = 27,
+   Start = 28,
+   Options = 29,
+   Share = 30,
+   Up = 31,
+   Down = 32,
+   Left = 33,
+   Right = 34,
+   LetterA = 35,
+   LetterB = 36,
+   LetterC = 37,
+   LetterL = 38,
+   LetterR = 39,
+   LetterX = 40,
+   LetterY = 41,
+   LetterZ = 42,
+   Cross = 43,
+   Circle = 44,
+   Square = 45,
+   Triangle = 46,
+   LeftBumper = 47,
+   LeftTrigger = 48,
+   LeftStickButton = 49,
+   Left1 = 50,
+   Left2 = 51,
+   Left3 = 52,
+   RightBumper = 53,
+   RightTrigger = 54,
+   RightStickButton = 55,
+   Right1 = 56,
+   Right2 = 57,
+   Right3 = 58,
+   Paddle1 = 59,
+   Paddle2 = 60,
+   Paddle3 = 61,
+   Paddle4 = 62,
+   Plus = 63,
+   Minus = 64,
+   DownLeftArrow = 65,
+   DialLeft = 66,
+   DialRight = 67,
+   Suspension = 68,
+ }

| public class Windows.Gaming.Input.Gamepad {
+   public GameControllerButtonLabel GetButtonLabel( GamepadButtons value );
| }

| public enum Windows.Gaming.Input.GamepadButtons {
+   Paddle1 = 16384,
+   Paddle2 = 32768,
+   Paddle3 = 65536,
+   Paddle4 = 131072,
| }

+ public enum Windows.Gaming.Input.OptionalUINavigationButtons {
+   None = 0,
+   Context1 = 1,
+   Context2 = 2,
+   Context3 = 4,
+   Context4 = 8,
+   PageUp = 16,
+   PageDown = 32,
+   PageLeft = 64,
+   PageRight = 128,
+   ScrollUp = 256,
+   ScrollDown = 512,
+   ScrollLeft = 1024,
+   ScrollRight = 2048,
+ }

+ public class Windows.Gaming.Input.RacingWheel {
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public bool HasClutch { get; }
+   public bool HasHandbrake { get; }
+   public bool HasPatternShifter { get; }
+   public int MaxPatternShifterGear { get; }
+   public double MaxWheelAngle { get; }
+   public ForceFeedbackMotor WheelMotor { get; }
+   public IVectorView<RacingWheel> RacingWheels { get; }
+   public GameControllerButtonLabel GetButtonLabel( RacingWheelButtons value );
+   public RacingWheelReading GetCurrentReading();
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<RacingWheel> RacingWheelAdded;
+   EventHandler<RacingWheel> RacingWheelRemoved;
+ }

+ public enum Windows.Gaming.Input.RacingWheelButtons {
+   None = 0,
+   PreviousGear = 1,
+   NextGear = 2,
+   DPadUp = 4,
+   DPadDown = 8,
+   DPadLeft = 16,
+   DPadRight = 32,
+   Button1 = 64,
+   Button2 = 128,
+   Button3 = 256,
+   Button4 = 512,
+   Button5 = 1024,
+   Button6 = 2048,
+   Button7 = 4096,
+   Button8 = 8192,
+   Button9 = 16384,
+   Button10 = 32768,
+   Button11 = 65536,
+   Button12 = 131072,
+   Button13 = 262144,
+   Button14 = 524288,
+   Button15 = 1048576,
+   Button16 = 2097152,
+ }

+ public struct Windows.Gaming.Input.RacingWheelReading {
+   public ulong Timestamp;
+   public RacingWheelButtons Buttons;
+   public int PatternShifterGear;
+   public double Wheel;
+   public double Throttle;
+   public double Brake;
+   public double Clutch;
+   public double Handbrake;
+ }

+ public enum Windows.Gaming.Input.RequiredUINavigationButtons {
+   None = 0,
+   Menu = 1,
+   View = 2,
+   Accept = 4,
+   Cancel = 8,
+   Up = 16,
+   Down = 32,
+   Left = 64,
+   Right = 128,
+ }

+ public class Windows.Gaming.Input.UINavigationController {
+   public Headset Headset { get; }
+   public bool IsWireless { get; }
+   public User User { get; }
+   public IVectorView<UINavigationController> UINavigationControllers { get; }
+   public UINavigationReading GetCurrentReading();
+   public GameControllerButtonLabel GetOptionalButtonLabel( OptionalUINavigationButtons value );
+   public GameControllerButtonLabel GetRequiredButtonLabel( RequiredUINavigationButtons value );
+   TypedEventHandler<IGameController, Headset> HeadsetConnected;
+   TypedEventHandler<IGameController, Headset> HeadsetDisconnected;
+   TypedEventHandler<IGameController, UserChangedEventArgs> UserChanged;
+   EventHandler<UINavigationController> UINavigationControllerAdded;
+   EventHandler<UINavigationController> UINavigationControllerRemoved;
+ }

+ public struct Windows.Gaming.Input.UINavigationReading {
+   public ulong Timestamp;
+   public RequiredUINavigationButtons RequiredButtons;
+   public OptionalUINavigationButtons OptionalButtons;
+ }

+ public class Windows.Gaming.Input.Custom.GameControllerFactoryManager {
+   public static void RegisterCustomFactoryForGipInterface( ICustomGameControllerFactory factory, Guid interfaceId );
+   public static void RegisterCustomFactoryForHardwareId( ICustomGameControllerFactory factory, ushort hardwareVendorId, ushort hardwareProductId );
+   public static void RegisterCustomFactoryForXusbType( ICustomGameControllerFactory factory, XusbDeviceType xusbType, XusbDeviceSubtype xusbSubtype );
+ }

+ public struct Windows.Gaming.Input.Custom.GameControllerVersionInfo {
+   public ushort Major;
+   public ushort Minor;
+   public ushort Build;
+   public ushort Revision;
+ }

+ public struct Windows.Gaming.Input.Custom.GipFirmwareUpdateProgress {
+   public double PercentCompleted;
+   public uint CurrentComponentId;
+ }

+ public class Windows.Gaming.Input.Custom.GipFirmwareUpdateResult {
+   public uint ExtendedErrorCode { get; }
+   public uint FinalComponentId { get; }
+   public GipFirmwareUpdateStatus Status { get; }
+ }

+ public enum Windows.Gaming.Input.Custom.GipFirmwareUpdateStatus {
+   Completed = 0,
+   UpToDate = 1,
+   Failed = 2,
+ }

+ public class Windows.Gaming.Input.Custom.GipGameControllerProvider {
+   public GameControllerVersionInfo FirmwareVersionInfo { get; }
+   public ushort HardwareProductId { get; }
+   public ushort HardwareVendorId { get; }
+   public GameControllerVersionInfo HardwareVersionInfo { get; }
+   public bool IsConnected { get; }
+   public void SendMessage( GipMessageClass messageClass, byte messageId, byte[] messageBuffer );
+   public void SendReceiveMessage( GipMessageClass messageClass, byte messageId, byte[] requestMessageBuffer, byte[] responseMessageBuffer );
+   public IAsyncOperationWithProgress<GipFirmwareUpdateResult, GipFirmwareUpdateProgress> UpdateFirmwareAsync( IInputStream result );
+ }

+ public enum Windows.Gaming.Input.Custom.GipMessageClass {
+   Command = 0,
+   LowLatency = 1,
+   StandardLatency = 2,
+ }

+ public interface Windows.Gaming.Input.Custom.ICustomGameControllerFactory {
+   public object CreateGameController( IGameControllerProvider value );
+   public void OnGameControllerAdded( IGameController value );
+   public void OnGameControllerRemoved( IGameController value );
+ }

+ public interface Windows.Gaming.Input.Custom.IGameControllerInputSink {
+   public void OnInputResumed( ulong timestamp );
+   public void OnInputSuspended( ulong timestamp );
+ }

+ public interface Windows.Gaming.Input.Custom.IGameControllerProvider {
+   public GameControllerVersionInfo FirmwareVersionInfo { get; }
+   public ushort HardwareProductId { get; }
+   public ushort HardwareVendorId { get; }
+   public GameControllerVersionInfo HardwareVersionInfo { get; }
+   public bool IsConnected { get; }
+ }

+ public interface Windows.Gaming.Input.Custom.IGipGameControllerInputSink {
+   public void OnKeyReceived( ulong timestamp, byte keyCode, bool isPressed );
+   public void OnMessageReceived( ulong timestamp, GipMessageClass messageClass, byte messageId, byte sequenceId, byte[] messageBuffer );
+ }

+ public interface Windows.Gaming.Input.Custom.IXusbGameControllerInputSink {
+   public void OnInputReceived( ulong timestamp, byte reportId, byte[] inputBuffer );
+ }

+ public enum Windows.Gaming.Input.Custom.XusbDeviceSubtype {
+   Unknown = 0,
+   Gamepad = 1,
+   ArcadePad = 2,
+   ArcadeStick = 3,
+   FlightStick = 4,
+   Wheel = 5,
+   Guitar = 6,
+   GuitarAlternate = 7,
+   GuitarBass = 8,
+   DrumKit = 9,
+   DancePad = 10,
+ }

+ public enum Windows.Gaming.Input.Custom.XusbDeviceType {
+   Unknown = 0,
+   Gamepad = 1,
+ }

+ public class Windows.Gaming.Input.Custom.XusbGameControllerProvider {
+   public GameControllerVersionInfo FirmwareVersionInfo { get; }
+   public ushort HardwareProductId { get; }
+   public ushort HardwareVendorId { get; }
+   public GameControllerVersionInfo HardwareVersionInfo { get; }
+   public bool IsConnected { get; }
+   public void SetVibration( double lowFrequencyMotorSpeed, double highFrequencyMotorSpeed );
+ }

+ public class Windows.Gaming.Input.ForceFeedback.ConditionForceEffect {
+   public ConditionForceEffectKind Kind { get; }
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public ConditionForceEffect( ConditionForceEffectKind effectKind );
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 direction, float positiveCoefficient, float negativeCoefficient, float maxPositiveMagnitude, float maxNegativeMagnitude, float deadZone, float bias );
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ConditionForceEffectKind {
+   Spring = 0,
+   Damper = 1,
+   Inertia = 2,
+   Friction = 3,
+ }

+ public class Windows.Gaming.Input.ForceFeedback.ConstantForceEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public ConstantForceEffect();
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 vector, TimeSpan duration );
+   public void SetParametersWithEnvelope( Vector3 vector, float attackGain, float sustainGain, float releaseGain, TimeSpan startDelay, TimeSpan attackDuration, TimeSpan sustainDuration, TimeSpan releaseDuration, uint repeatCount );
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ForceFeedbackEffectAxes {
+   None = 0,
+   X = 1,
+   Y = 2,
+   Z = 4,
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ForceFeedbackEffectState {
+   Stopped = 0,
+   Running = 1,
+   Paused = 2,
+   Faulted = 3,
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.ForceFeedbackLoadEffectResult {
+   Succeeded = 0,
+   EffectStorageFull = 1,
+   EffectNotSupported = 2,
+ }

+ public class Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor {
+   public double MasterGain { get; set; }
+   public bool AreEffectsPaused { get; }
+   public bool IsEnabled { get; }
+   public ForceFeedbackEffectAxes SupportedAxes { get; }
+   public IAsyncOperation<ForceFeedbackLoadEffectResult> LoadEffectAsync( IForceFeedbackEffect asyncOperation );
+   public void PauseAllEffects();
+   public void ResumeAllEffects();
+   public void StopAllEffects();
+   public IAsyncOperation<bool> TryDisableAsync();
+   public IAsyncOperation<bool> TryEnableAsync();
+   public IAsyncOperation<bool> TryResetAsync();
+   public IAsyncOperation<bool> TryUnloadEffectAsync( IForceFeedbackEffect asyncOperation );
+ }

+ public interface Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public void Start();
+   public void Stop();
+ }

+ public class Windows.Gaming.Input.ForceFeedback.PeriodicForceEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public PeriodicForceEffectKind Kind { get; }
+   public PeriodicForceEffect( PeriodicForceEffectKind effectKind );
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 vector, float frequency, float phase, float bias, TimeSpan duration );
+   public void SetParametersWithEnvelope( Vector3 vector, float frequency, float phase, float bias, float attackGain, float sustainGain, float releaseGain, TimeSpan startDelay, TimeSpan attackDuration, TimeSpan sustainDuration, TimeSpan releaseDuration, uint repeatCount );
+ }

+ public enum Windows.Gaming.Input.ForceFeedback.PeriodicForceEffectKind {
+   SquareWave = 0,
+   SineWave = 1,
+   TriangleWave = 2,
+   SawtoothWaveUp = 3,
+   SawtoothWaveDown = 4,
+ }

+ public class Windows.Gaming.Input.ForceFeedback.RampForceEffect {
+   public double Gain { get; set; }
+   public ForceFeedbackEffectState State { get; }
+   public RampForceEffect();
+   public void Start();
+   public void Stop();
+   public void SetParameters( Vector3 startVector, Vector3 endVector, TimeSpan duration );
+   public void SetParametersWithEnvelope( Vector3 startVector, Vector3 endVector, float attackGain, float sustainGain, float releaseGain, TimeSpan startDelay, TimeSpan attackDuration, TimeSpan sustainDuration, TimeSpan releaseDuration, uint repeatCount );
+ }

| public class Windows.Globalization.CalendarIdentifiers {
+   public string ChineseLunar { get; }
+   public string VietnameseLunar { get; }
+   public string TaiwanLunar { get; }
+   public string KoreanLunar { get; }
+   public string JapaneseLunar { get; }
| }

+ public enum Windows.Globalization.PhoneNumberFormatting.PhoneNumberFormat {
+   E164 = 0,
+   International = 1,
+   National = 2,
+   Rfc3966 = 3,
+ }

+ public class Windows.Globalization.PhoneNumberFormatting.PhoneNumberFormatter {
+   public PhoneNumberFormatter();
+   public string Format( PhoneNumberInfo result );
+   public string Format( PhoneNumberInfo result, PhoneNumberFormat number );
+   public string FormatPartialString( string result );
+   public string FormatString( string result );
+   public string FormatStringWithLeftToRightMarkers( string result );
+   public static void TryCreate( string regionCode, ref PhoneNumberFormatter phoneNumber );
+   public static int GetCountryCodeForRegion( string result );
+   public static string GetNationalDirectDialingPrefixForRegion( string result, bool regionCode );
+   public static string WrapWithLeftToRightMarkers( string result );
+ }

+ public class Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo {
+   public int CountryCode { get; }
+   public string PhoneNumber { get; }
+   public PhoneNumberInfo( string number );
+   public int GetLengthOfGeographicalAreaCode();
+   public string GetNationalSignificantNumber();
+   public int GetLengthOfNationalDestinationCode();
+   public PredictedPhoneNumberKind PredictNumberKind();
+   public string GetGeographicRegionCode();
+   public PhoneNumberMatchResult CheckNumberMatch( PhoneNumberInfo result );
+   public string ToString();
+   public static PhoneNumberParseResult TryParse( string result, ref PhoneNumberInfo input );
+   public static PhoneNumberParseResult TryParse( string result, string input, ref PhoneNumberInfo regionCode );
+ }

+ public enum Windows.Globalization.PhoneNumberFormatting.PhoneNumberMatchResult {
+   NoMatch = 0,
+   ShortNationalSignificantNumberMatch = 1,
+   NationalSignificantNumberMatch = 2,
+   ExactMatch = 3,
+ }

+ public enum Windows.Globalization.PhoneNumberFormatting.PhoneNumberParseResult {
+   Valid = 0,
+   NotANumber = 1,
+   InvalidCountryCode = 2,
+   TooShort = 3,
+   TooLong = 4,
+ }

+ public enum Windows.Globalization.PhoneNumberFormatting.PredictedPhoneNumberKind {
+   FixedLine = 0,
+   Mobile = 1,
+   FixedLineOrMobile = 2,
+   TollFree = 3,
+   PremiumRate = 4,
+   SharedCost = 5,
+   Voip = 6,
+   PersonalNumber = 7,
+   Pager = 8,
+   UniversalAccountNumber = 9,
+   Voicemail = 10,
+   Unknown = 11,
+ }

| public class Windows.Graphics.Display.DisplayInformation {
+   public uint ScreenHeightInRawPixels { get; }
+   public uint ScreenWidthInRawPixels { get; }
| }

+ public enum Windows.Graphics.Printing.PrintBordering {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   Bordered = 3,
+   Borderless = 4,
+ }

| public class Windows.Graphics.Printing.PrintManager {
+   public static bool IsSupported();
| }

+ public class Windows.Graphics.Printing.PrintPageInfo {
+   public Size PageSize { get; set; }
+   public PrintOrientation Orientation { get; set; }
+   public PrintMediaSize MediaSize { get; set; }
+   public uint DpiY { get; set; }
+   public uint DpiX { get; set; }
+   public PrintPageInfo();
+ }

| public class Windows.Graphics.Printing.PrintTask {
+   public bool IsPreviewEnabled { get; set; }
| }

| public class Windows.Graphics.Printing.PrintTaskOptions {
+   public PrintBordering Bordering { get; set; }
+   public IRandomAccessStream GetPagePrintTicket( PrintPageInfo printTicket );
| }

| public class Windows.Graphics.Printing.StandardPrintTaskOptions {
+   public string Bordering { get; }
| }

+ public class Windows.Graphics.Printing.OptionDetails.PrintBorderingOptionDetails {
+   public IVectorView<object> Items { get; }
+   public PrintOptionStates State { get; set; }
+   public string ErrorText { get; set; }
+   public string OptionId { get; }
+   public PrintOptionType OptionType { get; }
+   public object Value { get; }
+   public bool TrySetValue( object succeeded );
+ }

| public class Windows.Graphics.Printing3D.Printing3DCompositeMaterialGroup {
+   public Printing3DBaseMaterialGroup BaseMaterialGroup { get; set; }
| }

+ public class Windows.Graphics.Printing3D.Printing3DFaceReductionOptions {
+   public uint TargetTriangleCount { get; set; }
+   public double MaxReductionArea { get; set; }
+   public double MaxEdgeLength { get; set; }
+   public Printing3DFaceReductionOptions();
+ }

| public class Windows.Graphics.Printing3D.Printing3DModel {
+   public IAsyncOperation<bool> TryPartialRepairAsync();
+   public IAsyncOperation<bool> TryPartialRepairAsync( TimeSpan operation );
+   public IAsyncOperationWithProgress<bool, double> TryReduceFacesAsync();
+   public IAsyncOperationWithProgress<bool, double> TryReduceFacesAsync( Printing3DFaceReductionOptions operation );
+   public IAsyncOperationWithProgress<bool, double> TryReduceFacesAsync( Printing3DFaceReductionOptions operation, TimeSpan printing3DFaceReductionOptions );
+   public IAsyncOperationWithProgress<bool, double> RepairWithProgressAsync();
| }

| public class Windows.Management.Deployment.PackageManager {
+   public IAsyncOperation<IVectorView<PackageVolume>> GetPackageVolumesAsync();
| }

| public enum Windows.Management.Deployment.PackageTypes {
+   Optional = 32,
| }

| public class Windows.Management.Deployment.PackageVolume {
+   public bool IsAppxInstallSupported { get; }
+   public bool IsFullTrustPackageSupported { get; }
+   public IAsyncOperation<ulong> GetAvailableSpaceAsync();
| }

| public class Windows.Management.Workplace.MdmPolicy {
+   public static MessagingSyncPolicy GetMessagingSyncPolicy();
| }

+ public enum Windows.Management.Workplace.MessagingSyncPolicy {
+   Disallowed = 0,
+   Allowed = 1,
+   Required = 2,
+ }

+ public class Windows.Media.MediaTimelineController {
+   public TimeSpan Position { get; set; }
+   public double ClockRate { get; set; }
+   public MediaTimelineControllerState State { get; }
+   public MediaTimelineController();
+   public void Start();
+   public void Resume();
+   public void Pause();
+   TypedEventHandler<MediaTimelineController, object> PositionChanged;
+   TypedEventHandler<MediaTimelineController, object> StateChanged;
+ }

+ public enum Windows.Media.MediaTimelineControllerState {
+   Paused = 0,
+   Running = 1,
+ }

| public class Windows.Media.MusicDisplayProperties {
+   public uint AlbumTrackCount { get; set; }
| }

| public class Windows.Media.Audio.AudioDeviceInputNode {
+   public AudioNodeEmitter Emitter { get; }
| }

| public class Windows.Media.Audio.AudioDeviceOutputNode {
+   public AudioNodeListener Listener { get; set; }
| }

| public class Windows.Media.Audio.AudioFileInputNode {
+   public AudioNodeEmitter Emitter { get; }
| }

| public class Windows.Media.Audio.AudioFrameInputNode {
+   public AudioNodeEmitter Emitter { get; }
| }

| public class Windows.Media.Audio.AudioGraph {
+   public AudioFrameInputNode CreateFrameInputNode( AudioEncodingProperties frameInputNode, AudioNodeEmitter encodingProperties );
+   public IAsyncOperation<CreateAudioDeviceInputNodeResult> CreateDeviceInputNodeAsync( MediaCategory result, AudioEncodingProperties category, DeviceInformation encodingProperties, AudioNodeEmitter device );
+   public IAsyncOperation<CreateAudioFileInputNodeResult> CreateFileInputNodeAsync( IStorageFile result, AudioNodeEmitter file );
+   public AudioSubmixNode CreateSubmixNode( AudioEncodingProperties submixNode, AudioNodeEmitter encodingProperties );
+   public AudioGraphBatchUpdater CreateBatchUpdater();
| }

+ public class Windows.Media.Audio.AudioGraphBatchUpdater {
+   public void Close();
+ }

+ public class Windows.Media.Audio.AudioNodeEmitter {
+   public Vector3 Position { get; set; }
+   public double Gain { get; set; }
+   public Vector3 DopplerVelocity { get; set; }
+   public double DopplerScale { get; set; }
+   public double DistanceScale { get; set; }
+   public Vector3 Direction { get; set; }
+   public AudioNodeEmitterDecayModel DecayModel { get; }
+   public bool IsDopplerDisabled { get; }
+   public AudioNodeEmitterShape Shape { get; }
+   public SpatialAudioModel SpatialAudioModel { get; set; }
+   public AudioNodeEmitter( AudioNodeEmitterShape shape, AudioNodeEmitterDecayModel decayModel, AudioNodeEmitterSettings settings );
+   public AudioNodeEmitter();
+ }

+ public class Windows.Media.Audio.AudioNodeEmitterConeProperties {
+   public double InnerAngle { get; }
+   public double OuterAngle { get; }
+   public double OuterAngleGain { get; }
+ }

+ public enum Windows.Media.Audio.AudioNodeEmitterDecayKind {
+   Natural = 0,
+   Custom = 1,
+ }

+ public class Windows.Media.Audio.AudioNodeEmitterDecayModel {
+   public AudioNodeEmitterDecayKind Kind { get; }
+   public double MaxGain { get; }
+   public double MinGain { get; }
+   public AudioNodeEmitterNaturalDecayModelProperties NaturalProperties { get; }
+   public static AudioNodeEmitterDecayModel CreateNatural( double decayModel, double minGain, double maxGain, double unityGainDistance );
+   public static AudioNodeEmitterDecayModel CreateCustom( double decayModel, double minGain );
+ }

+ public class Windows.Media.Audio.AudioNodeEmitterNaturalDecayModelProperties {
+   public double CutoffDistance { get; }
+   public double UnityGainDistance { get; }
+ }

+ public enum Windows.Media.Audio.AudioNodeEmitterSettings {
+   None = 0,
+   DisableDoppler = 1,
+ }

+ public class Windows.Media.Audio.AudioNodeEmitterShape {
+   public AudioNodeEmitterConeProperties ConeProperties { get; }
+   public AudioNodeEmitterShapeKind Kind { get; }
+   public static AudioNodeEmitterShape CreateCone( double shape, double innerAngle, double outerAngle );
+   public static AudioNodeEmitterShape CreateOmnidirectional();
+ }

+ public enum Windows.Media.Audio.AudioNodeEmitterShapeKind {
+   Omnidirectional = 0,
+   Cone = 1,
+ }

+ public class Windows.Media.Audio.AudioNodeListener {
+   public double SpeedOfSound { get; set; }
+   public Vector3 Position { get; set; }
+   public Quaternion Orientation { get; set; }
+   public Vector3 DopplerVelocity { get; set; }
+   public AudioNodeListener();
+ }

| public class Windows.Media.Audio.AudioSubmixNode {
+   public AudioNodeEmitter Emitter { get; }
| }

+ public interface Windows.Media.Audio.IAudioInputNode2 {
+   public AudioNodeEmitter Emitter { get; }
+ }

+ public interface Windows.Media.Audio.IAudioNodeWithListener {
+   public AudioNodeListener Listener { get; set; }
+ }

+ public enum Windows.Media.Audio.SpatialAudioModel {
+   ObjectBased = 0,
+   FoldDown = 1,
+ }

| public class Windows.Media.Capture.AdvancedCapturedPhoto {
+   public IReference<Rect> FrameBoundsRelativeToReferencePhoto { get; }
| }

| public class Windows.Media.Capture.LowLagMediaRecording {
+   public IAsyncOperation<MediaCapturePauseResult> PauseWithResultAsync( MediaCapturePauseBehavior operation );
+   public IAsyncOperation<MediaCaptureStopResult> StopWithResultAsync();
| }

| public class Windows.Media.Capture.MediaCapture {
+   public IMapView<string, MediaFrameSource> FrameSources { get; }
+   public IAsyncAction RemoveEffectAsync( IMediaExtension asyncInfo );
+   public IAsyncOperation<MediaCapturePauseResult> PauseRecordWithResultAsync( MediaCapturePauseBehavior operation );
+   public IAsyncOperation<MediaCaptureStopResult> StopRecordWithResultAsync();
+   public IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync( MediaFrameSource value );
+   public IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync( MediaFrameSource value, string inputSource );
+   public IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync( MediaFrameSource value, string inputSource, BitmapSize outputSubtype );
| }

| public class Windows.Media.Capture.MediaCaptureInitializationSettings {
+   public MediaCaptureSharingMode SharingMode { get; set; }
+   public MediaFrameSourceGroup SourceGroup { get; set; }
+   public MediaCaptureMemoryPreference MemoryPreference { get; set; }
| }

+ public enum Windows.Media.Capture.MediaCaptureMemoryPreference {
+   Auto = 0,
+   Cpu = 1,
+ }

+ public class Windows.Media.Capture.MediaCapturePauseResult {
+   public VideoFrame LastFrame { get; }
+   public TimeSpan RecordDuration { get; }
+   public void Close();
+ }

+ public enum Windows.Media.Capture.MediaCaptureSharingMode {
+   ExclusiveControl = 0,
+   SharedReadOnly = 1,
+ }

+ public class Windows.Media.Capture.MediaCaptureStopResult {
+   public VideoFrame LastFrame { get; }
+   public TimeSpan RecordDuration { get; }
+   public void Close();
+ }

| public enum Windows.Media.Capture.PowerlineFrequency {
+   Auto = 3,
| }

+ public class Windows.Media.Capture.Frames.BufferMediaFrame {
+   public IBuffer Buffer { get; }
+   public MediaFrameReference FrameReference { get; }
+ }

+ public class Windows.Media.Capture.Frames.DepthMediaFrame {
+   public DepthMediaFrameFormat DepthFormat { get; }
+   public MediaFrameReference FrameReference { get; }
+   public VideoMediaFrame VideoMediaFrame { get; }
+   public DepthCorrelatedCoordinateMapper TryCreateCoordinateMapper( CameraIntrinsics value, SpatialCoordinateSystem cameraIntrinsics );
+ }

+ public class Windows.Media.Capture.Frames.DepthMediaFrameFormat {
+   public double DepthScaleInMeters { get; }
+   public VideoMediaFrameFormat VideoFormat { get; }
+ }

+ public class Windows.Media.Capture.Frames.InfraredMediaFrame {
+   public MediaFrameReference FrameReference { get; }
+   public bool IsIlluminated { get; }
+   public VideoMediaFrame VideoMediaFrame { get; }
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs {
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameFormat {
+   public MediaRatio FrameRate { get; }
+   public string MajorType { get; }
+   public IMapView<Guid, object> Properties { get; }
+   public string Subtype { get; }
+   public VideoMediaFrameFormat VideoFormat { get; }
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameReader {
+   public MediaFrameReference TryAcquireLatestFrame();
+   public IAsyncOperation<MediaFrameReaderStartStatus> StartAsync();
+   public IAsyncAction StopAsync();
+   public void Close();
+   TypedEventHandler<MediaFrameReader, MediaFrameArrivedEventArgs> FrameArrived;
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameReaderStartStatus {
+   Success = 0,
+   UnknownFailure = 1,
+   DeviceNotAvailable = 2,
+   OutputFormatNotSupported = 3,
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameReference {
+   public BufferMediaFrame BufferMediaFrame { get; }
+   public SpatialCoordinateSystem CoordinateSystem { get; }
+   public TimeSpan Duration { get; }
+   public MediaFrameFormat Format { get; }
+   public IMapView<Guid, object> Properties { get; }
+   public MediaFrameSourceKind SourceKind { get; }
+   public IReference<TimeSpan> SystemRelativeTime { get; }
+   public VideoMediaFrame VideoMediaFrame { get; }
+   public void Close();
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSource {
+   public MediaFrameSourceController Controller { get; }
+   public MediaFrameFormat CurrentFormat { get; }
+   public MediaFrameSourceInfo Info { get; }
+   public IVectorView<MediaFrameFormat> SupportedFormats { get; }
+   public IAsyncAction SetFormatAsync( MediaFrameFormat value );
+   public CameraIntrinsics TryGetCameraIntrinsics( MediaFrameFormat value );
+   TypedEventHandler<MediaFrameSource, object> FormatChanged;
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceController {
+   public VideoDeviceController VideoDeviceController { get; }
+   public IAsyncOperation<MediaFrameSourceGetPropertyResult> GetPropertyAsync( string value );
+   public IAsyncOperation<MediaFrameSourceSetPropertyStatus> SetPropertyAsync( string value, object propertyId );
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyResult {
+   public MediaFrameSourceGetPropertyStatus Status { get; }
+   public object Value { get; }
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyStatus {
+   Success = 0,
+   UnknownFailure = 1,
+   NotSupported = 2,
+   DeviceNotAvailable = 3,
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceGroup {
+   public string DisplayName { get; }
+   public string Id { get; }
+   public IVectorView<MediaFrameSourceInfo> SourceInfos { get; }
+   public static IAsyncOperation<IVectorView<MediaFrameSourceGroup>> FindAllAsync();
+   public static IAsyncOperation<MediaFrameSourceGroup> FromIdAsync( string value );
+   public static string GetDeviceSelector();
+ }

+ public class Windows.Media.Capture.Frames.MediaFrameSourceInfo {
+   public SpatialCoordinateSystem CoordinateSystem { get; }
+   public DeviceInformation DeviceInformation { get; }
+   public string Id { get; }
+   public MediaStreamType MediaStreamType { get; }
+   public IMapView<Guid, object> Properties { get; }
+   public MediaFrameSourceGroup SourceGroup { get; }
+   public MediaFrameSourceKind SourceKind { get; }
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameSourceKind {
+   Custom = 0,
+   Color = 1,
+   Infrared = 2,
+   Depth = 3,
+ }

+ public enum Windows.Media.Capture.Frames.MediaFrameSourceSetPropertyStatus {
+   Success = 0,
+   UnknownFailure = 1,
+   NotSupported = 2,
+   InvalidValue = 3,
+   DeviceNotAvailable = 4,
+   NotInControl = 5,
+ }

+ public class Windows.Media.Capture.Frames.VideoMediaFrame {
+   public CameraIntrinsics CameraIntrinsics { get; }
+   public DepthMediaFrame DepthMediaFrame { get; }
+   public IDirect3DSurface Direct3DSurface { get; }
+   public MediaFrameReference FrameReference { get; }
+   public InfraredMediaFrame InfraredMediaFrame { get; }
+   public SoftwareBitmap SoftwareBitmap { get; }
+   public VideoMediaFrameFormat VideoFormat { get; }
+   public VideoFrame GetVideoFrame();
+ }

+ public class Windows.Media.Capture.Frames.VideoMediaFrameFormat {
+   public DepthMediaFrameFormat DepthFormat { get; }
+   public uint Height { get; }
+   public MediaFrameFormat MediaFrameFormat { get; }
+   public uint Width { get; }
+ }

+ public enum Windows.Media.Core.AudioDecoderDegradation {
+   None = 0,
+   DownmixTo2Channels = 1,
+   DownmixTo6Channels = 2,
+   DownmixTo8Channels = 3,
+ }

+ public enum Windows.Media.Core.AudioDecoderDegradationReason {
+   None = 0,
+   LicensingRequirement = 1,
+ }

| public class Windows.Media.Core.AudioStreamDescriptor {
+   public IReference<uint> TrailingEncoderPadding { get; set; }
+   public IReference<uint> LeadingEncoderPadding { get; set; }
| }

| public class Windows.Media.Core.AudioTrack {
+   public string Name { get; }
+   public MediaPlaybackItem PlaybackItem { get; }
+   public AudioTrackSupportInfo SupportInfo { get; }
+   public AudioEncodingProperties GetEncodingProperties();
| }

+ public class Windows.Media.Core.AudioTrackOpenFailedEventArgs {
+   public HResult ExtendedError { get; }
+ }

+ public class Windows.Media.Core.AudioTrackSupportInfo {
+   public MediaDecoderStatus DecoderStatus { get; }
+   public AudioDecoderDegradation Degradation { get; }
+   public AudioDecoderDegradationReason DegradationReason { get; }
+   public MediaSourceStatus MediaSourceStatus { get; }
+ }

+ public enum Windows.Media.Core.MediaDecoderStatus {
+   FullySupported = 0,
+   UnsupportedSubtype = 1,
+   UnsupportedEncoderProperties = 2,
+   Degraded = 3,
+ }

+ public enum Windows.Media.Core.MediaSourceStatus {
+   FullySupported = 0,
+   Unknown = 1,
+ }

+ public class Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs {
+   public TimeSpan SampleLag { get; }
+ }

| public class Windows.Media.Core.TimedMetadataTrack {
+   public string Name { get; }
+   public MediaPlaybackItem PlaybackItem { get; }
| }

| public class Windows.Media.Core.VideoTrack {
+   public string Name { get; }
+   public MediaPlaybackItem PlaybackItem { get; }
+   public VideoTrackSupportInfo SupportInfo { get; }
+   public VideoEncodingProperties GetEncodingProperties();
| }

+ public class Windows.Media.Core.VideoTrackOpenFailedEventArgs {
+   public HResult ExtendedError { get; }
+ }

+ public class Windows.Media.Core.VideoTrackSupportInfo {
+   public MediaDecoderStatus DecoderStatus { get; }
+   public MediaSourceStatus MediaSourceStatus { get; }
+ }

| public enum Windows.Media.Devices.AdvancedPhotoMode {
+   LowLight = 3,
| }

| public class Windows.Media.Devices.Core.CameraIntrinsics {
+   public Matrix4x4 UndistortedProjectionTransform { get; }
+   public Point DistortPoint( Point result );
+   public void DistortPoints( Point[] inputs, Point[] results );
+   public Point UndistortPoint( Point result );
+   public void UndistortPoints( Point[] inputs, Point[] results );
| }

+ public class Windows.Media.Devices.Core.DepthCorrelatedCoordinateMapper {
+   public Vector3 UnprojectPoint( Point result, SpatialCoordinateSystem sourcePoint );
+   public void UnprojectPoints( Point[] sourcePoints, SpatialCoordinateSystem targetCoordinateSystem, Vector3[] results );
+   public Point MapPoint( Point result, SpatialCoordinateSystem sourcePoint, CameraIntrinsics targetCoordinateSystem );
+   public void MapPoints( Point[] sourcePoints, SpatialCoordinateSystem targetCoordinateSystem, CameraIntrinsics targetCameraIntrinsics, Point[] results );
+   public void Close();
+ }

| public class Windows.Media.Import.PhotoImportFindItemsResult {
+   public void AddItemsInDateRangeToSelection( DateTime rangeStart, TimeSpan rangeLength );
| }

| public class Windows.Media.Import.PhotoImportSession {
+   public PhotoImportSubfolderDateFormat SubfolderDateFormat { get; set; }
+   public bool RememberDeselectedItems { get; set; }
| }

+ public enum Windows.Media.Import.PhotoImportSubfolderDateFormat {
+   Year = 0,
+   YearMonth = 1,
+   YearMonthDay = 2,
+ }

+ public enum Windows.Media.MediaProperties.StereoscopicVideoPackingMode {
+   None = 0,
+   SideBySide = 1,
+   TopBottom = 2,
+ }

| public class Windows.Media.MediaProperties.VideoEncodingProperties {
+   public StereoscopicVideoPackingMode StereoscopicVideoPackingMode { get; }
| }

+ public class Windows.Media.Playback.MediaBreak {
+   public bool CanStart { get; set; }
+   public ValueSet CustomProperties { get; }
+   public MediaBreakInsertionMethod InsertionMethod { get; }
+   public MediaPlaybackList PlaybackList { get; }
+   public IReference<TimeSpan> PresentationPosition { get; }
+   public MediaBreak( MediaBreakInsertionMethod insertionMethod );
+   public MediaBreak( MediaBreakInsertionMethod insertionMethod, TimeSpan presentationPosition );
+ }

+ public class Windows.Media.Playback.MediaBreakEndedEventArgs {
+   public MediaBreak MediaBreak { get; }
+ }

+ public enum Windows.Media.Playback.MediaBreakInsertionMethod {
+   Interrupt = 0,
+   Replace = 1,
+ }

+ public class Windows.Media.Playback.MediaBreakManager {
+   public MediaBreak CurrentBreak { get; }
+   public MediaPlaybackSession PlaybackSession { get; }
+   public void PlayBreak( MediaBreak value );
+   public void SkipCurrentBreak();
+   TypedEventHandler<MediaBreakManager, MediaBreakEndedEventArgs> BreakEnded;
+   TypedEventHandler<MediaBreakManager, MediaBreakSkippedEventArgs> BreakSkipped;
+   TypedEventHandler<MediaBreakManager, MediaBreakStartedEventArgs> BreakStarted;
+   TypedEventHandler<MediaBreakManager, MediaBreakSeekedOverEventArgs> BreaksSeekedOver;
+ }

+ public class Windows.Media.Playback.MediaBreakSchedule {
+   public MediaBreak PrerollBreak { get; set; }
+   public MediaBreak PostrollBreak { get; set; }
+   public IVectorView<MediaBreak> MidrollBreaks { get; }
+   public MediaPlaybackItem PlaybackItem { get; }
+   public void InsertMidrollBreak( MediaBreak mediaBreak );
+   public void RemoveMidrollBreak( MediaBreak mediaBreak );
+   TypedEventHandler<MediaBreakSchedule, object> ScheduleChanged;
+ }

+ public class Windows.Media.Playback.MediaBreakSeekedOverEventArgs {
+   public TimeSpan NewPosition { get; }
+   public TimeSpan OldPosition { get; }
+   public IVectorView<MediaBreak> SeekedOverBreaks { get; }
+ }

+ public class Windows.Media.Playback.MediaBreakSkippedEventArgs {
+   public MediaBreak MediaBreak { get; }
+ }

+ public class Windows.Media.Playback.MediaBreakStartedEventArgs {
+   public MediaBreak MediaBreak { get; }
+ }

+ public enum Windows.Media.Playback.MediaCommandEnablingRule {
+   Auto = 0,
+   Always = 1,
+   Never = 2,
+ }

+ public class Windows.Media.Playback.MediaItemDisplayProperties {
+   public MediaPlaybackType Type { get; set; }
+   public RandomAccessStreamReference Thumbnail { get; set; }
+   public MusicDisplayProperties MusicProperties { get; }
+   public VideoDisplayProperties VideoProperties { get; }
+   public void ClearAll();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManager {
+   public bool IsEnabled { get; set; }
+   public MediaPlaybackCommandManagerCommandBehavior AutoRepeatModeBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior FastForwardBehavior { get; }
+   public MediaPlayer MediaPlayer { get; }
+   public MediaPlaybackCommandManagerCommandBehavior NextBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PauseBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PlayBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PositionBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior PreviousBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior RateBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior RewindBehavior { get; }
+   public MediaPlaybackCommandManagerCommandBehavior ShuffleBehavior { get; }
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs> AutoRepeatModeReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerFastForwardReceivedEventArgs> FastForwardReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerNextReceivedEventArgs> NextReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPauseReceivedEventArgs> PauseReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPlayReceivedEventArgs> PlayReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPositionReceivedEventArgs> PositionReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPreviousReceivedEventArgs> PreviousReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerRateReceivedEventArgs> RateReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerRewindReceivedEventArgs> RewindReceived;
+   TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerShuffleReceivedEventArgs> ShuffleReceived;
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs {
+   public bool Handled { get; set; }
+   public MediaPlaybackAutoRepeatMode AutoRepeatMode { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior {
+   public MediaCommandEnablingRule EnablingRule { get; set; }
+   public MediaPlaybackCommandManager CommandManager { get; }
+   public bool IsEnabled { get; }
+   TypedEventHandler<MediaPlaybackCommandManagerCommandBehavior, object> IsEnabledChanged;
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs {
+   public bool Handled { get; set; }
+   public TimeSpan Position { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs {
+   public bool Handled { get; set; }
+   public double PlaybackRate { get; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs {
+   public bool Handled { get; set; }
+   public Deferral GetDeferral();
+ }

+ public class Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs {
+   public bool Handled { get; set; }
+   public bool IsShuffleRequested { get; }
+   public Deferral GetDeferral();
+ }

| public class Windows.Media.Playback.MediaPlaybackItem {
+   public bool CanSkip { get; set; }
+   public MediaBreakSchedule BreakSchedule { get; }
+   public IReference<TimeSpan> DurationLimit { get; }
+   public TimeSpan StartTime { get; }
+   public MediaPlaybackItem( MediaSource source, TimeSpan startTime );
+   public MediaPlaybackItem( MediaSource source, TimeSpan startTime, TimeSpan durationLimit );
+   public MediaItemDisplayProperties GetDisplayProperties();
+   public void ApplyDisplayProperties( MediaItemDisplayProperties value );
| }

+ public class Windows.Media.Playback.MediaPlaybackSession {
+   public StereoscopicVideoPackingMode StereoscopicVideoPackingMode { get; set; }
+   public double PlaybackRate { get; set; }
+   public Rect NormalizedSourceRect { get; set; }
+   public TimeSpan Position { get; set; }
+   public bool IsProtected { get; }
+   public MediaPlayer MediaPlayer { get; }
+   public TimeSpan NaturalDuration { get; }
+   public uint NaturalVideoWidth { get; }
+   public double BufferingProgress { get; }
+   public bool CanPause { get; }
+   public bool CanSeek { get; }
+   public MediaPlaybackState PlaybackState { get; }
+   public uint NaturalVideoHeight { get; }
+   public double DownloadProgress { get; }
+   TypedEventHandler<MediaPlaybackSession, object> BufferingEnded;
+   TypedEventHandler<MediaPlaybackSession, object> BufferingProgressChanged;
+   TypedEventHandler<MediaPlaybackSession, object> BufferingStarted;
+   TypedEventHandler<MediaPlaybackSession, object> DownloadProgressChanged;
+   TypedEventHandler<MediaPlaybackSession, object> NaturalDurationChanged;
+   TypedEventHandler<MediaPlaybackSession, object> NaturalVideoSizeChanged;
+   TypedEventHandler<MediaPlaybackSession, object> PlaybackRateChanged;
+   TypedEventHandler<MediaPlaybackSession, object> PlaybackStateChanged;
+   TypedEventHandler<MediaPlaybackSession, object> PositionChanged;
+   TypedEventHandler<MediaPlaybackSession, object> SeekCompleted;
+ }

+ public enum Windows.Media.Playback.MediaPlaybackState {
+   None = 0,
+   Opening = 1,
+   Buffering = 2,
+   Playing = 3,
+   Paused = 4,
+ }

| public class Windows.Media.Playback.MediaPlayer {
+   public MediaTimelineController TimelineController { get; set; }
+   public StereoscopicVideoRenderMode StereoscopicVideoRenderMode { get; set; }
+   public DeviceInformation AudioDevice { get; set; }
+   public double AudioBalance { get; set; }
+   public bool RealTimePlayback { get; set; }
+   public TimeSpan TimelineControllerPositionOffset { get; set; }
+   public MediaPlaybackSession PlaybackSession { get; }
+   public MediaBreakManager BreakManager { get; }
+   public MediaPlaybackCommandManager CommandManager { get; }
+   public MediaPlayer();
+   public void Close();
+   public void StepForwardOneFrame();
+   public void StepBackwardOneFrame();
+   public CastingSource GetAsCastingSource();
+   public void SetSurfaceSize( Size size );
+   public MediaPlayerSurface GetSurface( Compositor result );
+   public void AddVideoEffect( string activatableClassId, bool effectOptional, IPropertySet effectConfiguration );
| }

+ public class Windows.Media.Playback.MediaPlayerSurface {
+   public ICompositionSurface CompositionSurface { get; }
+   public Compositor Compositor { get; }
+   public MediaPlayer MediaPlayer { get; }
+   public void Close();
+ }

+ public enum Windows.Media.Playback.StereoscopicVideoRenderMode {
+   Mono = 0,
+   Stereo = 1,
+ }

+ public enum Windows.Media.Protection.HdcpProtection {
+   Off = 0,
+   On = 1,
+   OnWithTypeEnforcement = 2,
+ }

+ public class Windows.Media.Protection.HdcpSession {
+   public HdcpSession();
+   public bool IsEffectiveProtectionAtLeast( HdcpProtection value );
+   public IReference<HdcpProtection> GetEffectiveProtection();
+   public IAsyncOperation<HdcpSetProtectionResult> SetDesiredMinProtectionAsync( HdcpProtection value );
+   public void Close();
+   TypedEventHandler<HdcpSession, object> ProtectionChanged;
+ }

+ public enum Windows.Media.Protection.HdcpSetProtectionResult {
+   Success = 0,
+   TimedOut = 1,
+   NotSupported = 2,
+   UnknownFailure = 3,
+ }

| public class Windows.Media.Protection.ProtectionCapabilities {
+   public ProtectionCapabilities();
| }

| public class Windows.Media.Protection.PlayReady.PlayReadyLicenseAcquisitionServiceRequest {
+   public Guid SessionId { get; }
| }

| public class Windows.Media.Protection.PlayReady.PlayReadyStatics {
+   public string InputTrustAuthorityToCreate { get; }
+   public Guid ProtectionSystemId { get; }
| }

| public class Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadResult {
+   public IReference<ulong> ResourceByteRangeOffset { get; set; }
+   public IReference<ulong> ResourceByteRangeLength { get; set; }
| }

| public class Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager {
+   public static NetworkOperatorTetheringManager CreateFromConnectionProfile( ConnectionProfile ppManager, NetworkAdapter profile );
| }

| public enum Windows.Networking.NetworkOperators.TetheringOperationStatus {
+   BluetoothDeviceOff = 7,
+   NetworkLimitedConnectivity = 8,
| }

| public class Windows.Networking.PushNotifications.PushNotificationChannelManager {
+   public static PushNotificationChannelManagerForUser GetForUser( User result );
| }

+ public class Windows.Networking.PushNotifications.PushNotificationChannelManagerForUser {
+   public User User { get; }
+   public IAsyncOperation<PushNotificationChannel> CreatePushNotificationChannelForApplicationAsync();
+   public IAsyncOperation<PushNotificationChannel> CreatePushNotificationChannelForApplicationAsync( string operation );
+   public IAsyncOperation<PushNotificationChannel> CreatePushNotificationChannelForSecondaryTileAsync( string operation );
+ }

| public class Windows.Networking.Sockets.ControlChannelTrigger {
+   public bool IsWakeFromLowPowerSupported { get; }
| }

+ public interface Windows.Networking.Sockets.IWebSocketControl2 {
+   public IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
+ }

+ public interface Windows.Networking.Sockets.IWebSocketInformation2 {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
+ }

| public class Windows.Networking.Sockets.MessageWebSocketControl {
+   public IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
| }

| public class Windows.Networking.Sockets.MessageWebSocketInformation {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
| }

| public class Windows.Networking.Sockets.StreamSocket {
+   public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync( HostName operation, string remoteHostName );
+   public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync( HostName operation, string remoteHostName, HostNameSortOptions remoteServiceName );
| }

| public class Windows.Networking.Sockets.StreamWebSocketControl {
+   public IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
| }

| public class Windows.Networking.Sockets.StreamWebSocketInformation {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
| }

+ public class Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs {
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
+   public void Reject();
+   public Deferral GetDeferral();
+ }

| public class Windows.Networking.Vpn.VpnDomainNameInfo {
+   public IVector<Uri> WebProxyUris { get; }
| }

+ public enum Windows.Networking.Vpn.VpnManagementConnectionStatus {
+   Disconnected = 0,
+   Disconnecting = 1,
+   Connected = 2,
+   Connecting = 3,
+ }

| public enum Windows.Networking.Vpn.VpnManagementErrorStatus {
+   CannotFindProfile = 6,
+   AlreadyDisconnecting = 7,
+   AlreadyConnected = 8,
+   GeneralAuthenticationFailure = 9,
+   EapFailure = 10,
+   SmartCardFailure = 11,
+   CertificateFailure = 12,
+   ServerConfiguration = 13,
+   NoConnection = 14,
+   ServerConnection = 15,
+   UserNamePassword = 16,
+   DnsNotResolvable = 17,
+   InvalidIP = 18,
| }

| public class Windows.Networking.Vpn.VpnNativeProfile {
+   public bool RequireVpnClientAppUI { get; set; }
+   public VpnManagementConnectionStatus ConnectionStatus { get; }
| }

| public class Windows.Networking.Vpn.VpnPlugInProfile {
+   public bool RequireVpnClientAppUI { get; set; }
+   public VpnManagementConnectionStatus ConnectionStatus { get; }
| }

| public class Windows.Perception.Spatial.SpatialAnchor {
+   public bool RemovedByUser { get; }
| }

+ public class Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationInfo {
+   public string KeyId { get; }
+   public string KeyName { get; }
+   public string Subject { get; }
+   public string TenantId { get; }
+   public string TenantName { get; }
+ }

+ public class Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationManager {
+   public EnterpriseKeyCredentialRegistrationManager Current { get; }
+   public IAsyncOperation<IVectorView<EnterpriseKeyCredentialRegistrationInfo>> GetRegistrationsAsync();
+ }

+ public class Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorAuthenticationManager {
+   public MicrosoftAccountMultiFactorAuthenticationManager Current { get; }
+   public IAsyncOperation<MicrosoftAccountMultiFactorOneTimeCodedInfo> GetOneTimePassCodeAsync( string asyncOperation, uint userAccountId );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> AddDeviceAsync( string asyncOperation, string userAccountId, string authenticationToken );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> RemoveDeviceAsync( string asyncOperation );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> UpdateWnsChannelAsync( string asyncOperation, string userAccountId );
+   public IAsyncOperation<MicrosoftAccountMultiFactorGetSessionsResult> GetSessionsAsync( IIterable<string> asyncOperation );
+   public IAsyncOperation<MicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo> GetSessionsAndUnregisteredAccountsAsync( IIterable<string> asyncOperation );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync( MicrosoftAccountMultiFactorSessionAuthenticationStatus asyncOperation, MicrosoftAccountMultiFactorSessionInfo sessionAuthentictionStatus );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync( MicrosoftAccountMultiFactorSessionAuthenticationStatus asyncOperation, string sessionAuthentictionStatus, string userAccountId, MicrosoftAccountMultiFactorAuthenticationType sessionId );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> DenySessionAsync( MicrosoftAccountMultiFactorSessionInfo asyncOperation );
+   public IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> DenySessionAsync( string asyncOperation, string userAccountId, MicrosoftAccountMultiFactorAuthenticationType sessionId );
+ }

+ public enum Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorAuthenticationType {
+   User = 0,
+   Device = 1,
+ }

+ public class Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorGetSessionsResult {
+   public MicrosoftAccountMultiFactorServiceResponse ServiceResponse { get; }
+   public IVectorView<MicrosoftAccountMultiFactorSessionInfo> Sessions { get; }
+ }

+ public class Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorOneTimeCodedInfo {
+   public string Code { get; }
+   public MicrosoftAccountMultiFactorServiceResponse ServiceResponse { get; }
+   public TimeSpan TimeInterval { get; }
+   public TimeSpan TimeToLive { get; }
+ }

+ public enum Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorServiceResponse {
+   Success = 0,
+   Error = 1,
+   NoNetworkConnection = 2,
+   ServiceUnavailable = 3,
+   TotpSetupDenied = 4,
+   NgcNotSetup = 5,
+   SessionAlreadyDenied = 6,
+   SessionAlreadyApproved = 7,
+   SessionExpired = 8,
+   NgcNonceExpired = 9,
+   InvalidSessionId = 10,
+   InvalidSessionType = 11,
+   InvalidOperation = 12,
+   InvalidStateTransition = 13,
+   DeviceNotFound = 14,
+   FlowDisabled = 15,
+   SessionNotApproved = 16,
+   OperationCanceledByUser = 17,
+   NgcDisabledByServer = 18,
+   NgcKeyNotFoundOnServer = 19,
+   UIRequired = 20,
+   DeviceIdChanged = 21,
+ }

+ public enum Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionApprovalStatus {
+   Pending = 0,
+   Approved = 1,
+   Denied = 2,
+ }

+ public enum Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionAuthenticationStatus {
+   Authenticated = 0,
+   Unauthenticated = 1,
+ }

+ public class Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo {
+   public MicrosoftAccountMultiFactorSessionApprovalStatus ApprovalStatus { get; }
+   public MicrosoftAccountMultiFactorAuthenticationType AuthenticationType { get; }
+   public string DisplaySessionId { get; }
+   public DateTime ExpirationTime { get; }
+   public DateTime RequestTime { get; }
+   public string SessionId { get; }
+   public string UserAccountId { get; }
+ }

+ public class Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo {
+   public MicrosoftAccountMultiFactorServiceResponse ServiceResponse { get; }
+   public IVectorView<MicrosoftAccountMultiFactorSessionInfo> Sessions { get; }
+   public IVectorView<string> UnregisteredAccounts { get; }
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication {
+   public IBuffer DeviceConfigurationData { get; }
+   public IBuffer DeviceNonce { get; }
+   public IBuffer ServiceAuthenticationHmac { get; }
+   public IBuffer SessionNonce { get; }
+   public IAsyncOperation<SecondaryAuthenticationFactorFinishAuthenticationStatus> FinishAuthenticationAsync( IBuffer result, IBuffer deviceHmac );
+   public IAsyncAction AbortAuthenticationAsync( string result );
+   public static IAsyncAction ShowNotificationMessageAsync( string result, SecondaryAuthenticationFactorAuthenticationMessage deviceName );
+   public static IAsyncOperation<SecondaryAuthenticationFactorAuthenticationResult> StartAuthenticationAsync( string operation, IBuffer deviceId );
+   public static IAsyncOperation<SecondaryAuthenticationFactorAuthenticationStageInfo> GetAuthenticationStageInfoAsync();
+   EventHandler<SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs> AuthenticationStageChanged;
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationMessage {
+   Invalid = 0,
+   SwipeUpWelcome = 1,
+   TapWelcome = 2,
+   DeviceNeedsAttention = 3,
+   LookingForDevice = 4,
+   LookingForDevicePluggedin = 5,
+   BluetoothIsDisabled = 6,
+   NfcIsDisabled = 7,
+   WiFiIsDisabled = 8,
+   ExtraTapIsRequired = 9,
+   DisabledByPolicy = 10,
+   TapOnDeviceRequired = 11,
+   HoldFinger = 12,
+   ScanFinger = 13,
+   UnauthorizedUser = 14,
+   ReregisterRequired = 15,
+   TryAgain = 16,
+   SayPassphrase = 17,
+   ReadyToSignIn = 18,
+   UseAnotherSignInOption = 19,
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationResult {
+   public SecondaryAuthenticationFactorAuthentication Authentication { get; }
+   public SecondaryAuthenticationFactorAuthenticationStatus Status { get; }
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationScenario {
+   SignIn = 0,
+   CredentialPrompt = 1,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStage {
+   NotStarted = 0,
+   WaitingForUserConfirmation = 1,
+   CollectingCredential = 2,
+   SuspendingAuthentication = 3,
+   CredentialCollected = 4,
+   CredentialAuthenticated = 5,
+   StoppingAuthentication = 6,
+   ReadyForLock = 7,
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs {
+   public SecondaryAuthenticationFactorAuthenticationStageInfo StageInfo { get; }
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo {
+   public string DeviceId { get; }
+   public SecondaryAuthenticationFactorAuthenticationScenario Scenario { get; }
+   public SecondaryAuthenticationFactorAuthenticationStage Stage { get; }
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStatus {
+   Failed = 0,
+   Started = 1,
+   UnknownDevice = 2,
+   DisabledByPolicy = 3,
+   InvalidAuthenticationStage = 4,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorDeviceCapabilities {
+   None = 0,
+   SecureStorage = 1,
+   StoreKeys = 2,
+   ConfirmUserIntentToAuthenticate = 4,
+   SupportSecureUserPresenceCheck = 8,
+   TransmittedDataIsEncrypted = 16,
+   HMacSha256 = 32,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorDeviceFindScope {
+   User = 0,
+   AllUsers = 1,
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorFinishAuthenticationStatus {
+   Failed = 0,
+   Completed = 1,
+   NonceExpired = 2,
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo {
+   public IBuffer DeviceConfigurationData { get; }
+   public string DeviceFriendlyName { get; }
+   public string DeviceId { get; }
+   public string DeviceModelNumber { get; }
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration {
+   public IAsyncAction FinishRegisteringDeviceAsync( IBuffer result );
+   public IAsyncAction AbortRegisteringDeviceAsync( string result );
+   public static IAsyncOperation<SecondaryAuthenticationFactorRegistrationResult> RequestStartRegisteringDeviceAsync( string operation, SecondaryAuthenticationFactorDeviceCapabilities deviceId, string capabilities, string deviceFriendlyName, IBuffer deviceModelNumber, IBuffer deviceKey );
+   public static IAsyncOperation<IVectorView<SecondaryAuthenticationFactorInfo>> FindAllRegisteredDeviceInfoAsync( SecondaryAuthenticationFactorDeviceFindScope deviceInfoList );
+   public static IAsyncAction UnregisterDeviceAsync( string result );
+   public static IAsyncAction UpdateDeviceConfigurationDataAsync( string result, IBuffer deviceId );
+ }

+ public class Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationResult {
+   public SecondaryAuthenticationFactorRegistration Registration { get; }
+   public SecondaryAuthenticationFactorRegistrationStatus Status { get; }
+ }

+ public enum Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationStatus {
+   Failed = 0,
+   Started = 1,
+   CanceledByUser = 2,
+   PinSetupRequired = 3,
+   DisabledByPolicy = 4,
+ }

| public enum Windows.Security.Authentication.Web.TokenBindingKeyType {
+   AnyExisting = 2,
| }

+ public class Windows.Security.Authentication.Web.Core.WebAccountEventArgs {
+   public WebAccount Account { get; }
+ }

+ public class Windows.Security.Authentication.Web.Core.WebAccountMonitor {
+   TypedEventHandler<WebAccountMonitor, object> DefaultSignInAccountChanged;
+   TypedEventHandler<WebAccountMonitor, WebAccountEventArgs> Removed;
+   TypedEventHandler<WebAccountMonitor, WebAccountEventArgs> Updated;
+ }

| public class Windows.Security.Authentication.Web.Core.WebAuthenticationCoreManager {
+   public static WebAccountMonitor CreateWebAccountMonitor( IIterable<WebAccount> result );
| }

| public class Windows.Security.Authentication.Web.Provider.WebAccountManager {
+   public static IAsyncOperation<WebAccount> AddWebAccountAsync( string asyncInfo, string webAccountId, IMapView<string, string> webAccountUserName, WebAccountScope props, string scope );
+   public static IAsyncAction SetPerAppToPerUserAccountAsync( WebAccount asyncInfo, string perAppAccount );
+   public static IAsyncOperation<WebAccount> GetPerUserFromPerAppAccountAsync( WebAccount asyncInfo );
+   public static IAsyncAction ClearPerUserFromPerAppAccountAsync( WebAccount asyncInfo );
| }

| public class Windows.Security.Authentication.Web.Provider.WebProviderTokenRequest {
+   public IAsyncOperation<IBuffer> GetApplicationTokenBindingKeyIdAsync( TokenBindingKeyType asyncInfo, Uri keyType );
| }

| public class Windows.Security.Cryptography.Certificates.Certificate {
+   public bool IsPerUser { get; }
+   public string KeyStorageProviderName { get; }
+   public string StoreName { get; }
| }

| public class Windows.Security.Cryptography.Certificates.CertificateStores {
+   public static UserCertificateStore GetUserStoreByName( string result );
| }

+ public class Windows.Security.Cryptography.Certificates.StandardCertificateStoreNames {
+   public string IntermediateCertificationAuthorities { get; }
+   public string Personal { get; }
+   public string TrustedRootCertificationAuthorities { get; }
+ }

+ public class Windows.Security.Cryptography.Certificates.UserCertificateStore {
+   public string Name { get; }
+   public IAsyncOperation<bool> RequestAddAsync( Certificate result );
+   public IAsyncOperation<bool> RequestDeleteAsync( Certificate result );
+ }

| public enum Windows.Security.EnterpriseData.FileProtectionStatus {
+   FileInUse = 10,
| }

+ public enum Windows.Security.EnterpriseData.ProtectionPolicyAuditAction {
+   Decrypt = 0,
+   CopyToLocation = 1,
+   SendToRecipient = 2,
+   Other = 3,
+ }

+ public class Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo {
+   public string TargetDescription { get; set; }
+   public string SourceDescription { get; set; }
+   public string DataDescription { get; set; }
+   public ProtectionPolicyAuditAction Action { get; set; }
+   public ProtectionPolicyAuditInfo( ProtectionPolicyAuditAction action, string dataDescription, string sourceDescription, string targetDescription );
+   public ProtectionPolicyAuditInfo( ProtectionPolicyAuditAction action, string dataDescription );
+ }

| public class Windows.Security.EnterpriseData.ProtectionPolicyManager {
+   public bool ShowEnterpriseIndicator { get; set; }
+   public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessAsync( string result, string sourceIdentity, ProtectionPolicyAuditInfo targetIdentity );
+   public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessAsync( string result, string sourceIdentity, ProtectionPolicyAuditInfo targetIdentity, string auditInfo );
+   public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessForAppAsync( string result, string sourceIdentity, ProtectionPolicyAuditInfo appPackageFamilyName );
+   public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessForAppAsync( string result, string sourceIdentity, ProtectionPolicyAuditInfo appPackageFamilyName, string auditInfo );
+   public static void LogAuditEvent( string sourceIdentity, string targetIdentity, ProtectionPolicyAuditInfo auditInfo );
| }

+ public enum Windows.Security.EnterpriseData.ProtectionPolicyRequestAccessBehavior {
+   Decrypt = 0,
+   TreatOverridePolicyAsBlock = 1,
+ }

+ public enum Windows.Services.Maps.MapLocationDesiredAccuracy {
+   High = 0,
+   Low = 1,
+ }

| public class Windows.Services.Maps.MapLocationFinder {
+   public static IAsyncOperation<MapLocationFinderResult> FindLocationsAtAsync( Geopoint result, MapLocationDesiredAccuracy queryPoint );
| }

| public class Windows.Services.Maps.LocalSearch.LocalLocation {
+   public string Category { get; }
+   public IVectorView<LocalLocationHoursOfOperationItem> HoursOfOperation { get; }
+   public LocalLocationRatingInfo RatingInfo { get; }
| }

+ public class Windows.Services.Maps.LocalSearch.LocalLocationHoursOfOperationItem {
+   public DayOfWeek Day { get; }
+   public TimeSpan Span { get; }
+   public TimeSpan Start { get; }
+ }

+ public class Windows.Services.Maps.LocalSearch.LocalLocationRatingInfo {
+   public IReference<double> AggregateRating { get; }
+   public string ProviderIdentifier { get; }
+   public IReference<int> RatingCount { get; }
+ }

+ public class Windows.Services.Store.StoreAcquireLicenseResult {
+   public HResult ExtendedError { get; }
+   public StorePackageLicense StorePackageLicense { get; }
+ }

+ public class Windows.Services.Store.StoreAppLicense {
+   public IMapView<string, StoreLicense> AddOnLicenses { get; }
+   public DateTime ExpirationDate { get; }
+   public string ExtendedJsonData { get; }
+   public bool IsActive { get; }
+   public bool IsTrial { get; }
+   public bool IsTrialOwnedByThisUser { get; }
+   public string SkuStoreId { get; }
+   public TimeSpan TrialTimeRemaining { get; }
+   public string TrialUniqueId { get; }
+ }

+ public class Windows.Services.Store.StoreAvailability {
+   public DateTime EndDate { get; }
+   public string ExtendedJsonData { get; }
+   public StorePrice Price { get; }
+   public string StoreId { get; }
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( StorePurchaseProperties operation );
+ }

+ public class Windows.Services.Store.StoreCollectionData {
+   public DateTime AcquiredDate { get; }
+   public string CampaignId { get; }
+   public string DeveloperOfferId { get; }
+   public DateTime EndDate { get; }
+   public string ExtendedJsonData { get; }
+   public bool IsTrial { get; }
+   public DateTime StartDate { get; }
+   public TimeSpan TrialTimeRemaining { get; }
+ }

+ public class Windows.Services.Store.StoreConsumableResult {
+   public uint BalanceRemaining { get; }
+   public HResult ExtendedError { get; }
+   public StoreConsumableStatus Status { get; }
+   public Guid TrackingId { get; }
+ }

+ public enum Windows.Services.Store.StoreConsumableStatus {
+   Succeeded = 0,
+   InsufficentQuantity = 1,
+   NetworkError = 2,
+   ServerError = 3,
+ }

+ public class Windows.Services.Store.StoreContext {
+   public User User { get; }
+   public IAsyncOperation<string> GetCustomerPurchaseIdAsync( string operation, string serviceTicket );
+   public IAsyncOperation<string> GetCustomerCollectionsIdAsync( string operation, string serviceTicket );
+   public IAsyncOperation<StoreAppLicense> GetAppLicenseAsync();
+   public IAsyncOperation<StoreProductResult> GetStoreProductForCurrentAppAsync();
+   public IAsyncOperation<StoreProductQueryResult> GetStoreProductsAsync( IIterable<string> operation, IIterable<string> productKinds );
+   public IAsyncOperation<StoreProductQueryResult> GetAssociatedStoreProductsAsync( IIterable<string> operation );
+   public IAsyncOperation<StoreProductPagedQueryResult> GetAssociatedStoreProductsWithPagingAsync( IIterable<string> operation, uint productKinds );
+   public IAsyncOperation<StoreProductQueryResult> GetUserCollectionAsync( IIterable<string> operation );
+   public IAsyncOperation<StoreProductPagedQueryResult> GetUserCollectionWithPagingAsync( IIterable<string> operation, uint productKinds );
+   public IAsyncOperation<StoreConsumableResult> ReportConsumableFulfillmentAsync( string operation, uint productStoreId, Guid quantity );
+   public IAsyncOperation<StoreConsumableResult> GetConsumableBalanceRemainingAsync( string operation );
+   public IAsyncOperation<StoreAcquireLicenseResult> AcquireStoreLicenseForOptionalPackageAsync( Package operation );
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( string operation );
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( string operation, StorePurchaseProperties storeId );
+   public IAsyncOperation<IVectorView<StorePackageUpdate>> GetAppAndOptionalStorePackageUpdatesAsync();
+   public IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadStorePackageUpdatesAsync( IIterable<StorePackageUpdate> operation );
+   public IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackageUpdatesAsync( IIterable<StorePackageUpdate> operation );
+   public IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackagesAsync( IIterable<string> operation );
+   public static StoreContext GetDefault();
+   public static StoreContext GetForUser( User value );
+   TypedEventHandler<StoreContext, object> OfflineLicensesChanged;
+ }

+ public struct Windows.Services.Store.StoreContract {
+ }

+ public enum Windows.Services.Store.StoreDurationUnit {
+   Minute = 0,
+   Hour = 1,
+   Day = 2,
+   Week = 3,
+   Month = 4,
+   Year = 5,
+ }

+ public class Windows.Services.Store.StoreImage {
+   public string Caption { get; }
+   public uint Height { get; }
+   public string ImagePurposeTag { get; }
+   public Uri Uri { get; }
+   public uint Width { get; }
+ }

+ public class Windows.Services.Store.StoreLicense {
+   public DateTime ExpirationDate { get; }
+   public string ExtendedJsonData { get; }
+   public string InAppOfferToken { get; }
+   public bool IsActive { get; }
+   public string SkuStoreId { get; }
+ }

+ public class Windows.Services.Store.StorePackageLicense {
+   public bool IsValid { get; }
+   public Package Package { get; }
+   public void ReleaseLicense();
+   public void Close();
+   TypedEventHandler<StorePackageLicense, object> LicenseLost;
+ }

+ public class Windows.Services.Store.StorePackageUpdate {
+   public bool Mandatory { get; }
+   public Package Package { get; }
+ }

+ public class Windows.Services.Store.StorePackageUpdateResult {
+   public StorePackageUpdateState OverallState { get; }
+   public IVectorView<StorePackageUpdateStatus> StorePackageUpdateStatuses { get; }
+ }

+ public enum Windows.Services.Store.StorePackageUpdateState {
+   Pending = 0,
+   Downloading = 1,
+   Deploying = 2,
+   Completed = 3,
+   Canceled = 4,
+   OtherError = 5,
+   ErrorLowBattery = 6,
+   ErrorWiFiRecommended = 7,
+   ErrorWiFiRequired = 8,
+ }

+ public struct Windows.Services.Store.StorePackageUpdateStatus {
+   public string PackageFamilyName;
+   public ulong PackageDownloadSizeInBytes;
+   public ulong PackageBytesDownloaded;
+   public double PackageDownloadProgress;
+   public double TotalDownloadProgress;
+   public StorePackageUpdateState PackageUpdateState;
+ }

+ public class Windows.Services.Store.StorePrice {
+   public string CurrencyCode { get; }
+   public string FormattedBasePrice { get; }
+   public string FormattedPrice { get; }
+   public string FormattedRecurrencePrice { get; }
+   public bool IsOnSale { get; }
+   public DateTime SaleEndDate { get; }
+ }

+ public class Windows.Services.Store.StoreProduct {
+   public string Description { get; }
+   public string ExtendedJsonData { get; }
+   public bool HasDigitalDownload { get; }
+   public IVectorView<StoreImage> Images { get; }
+   public string InAppOfferToken { get; }
+   public bool IsInUserCollection { get; }
+   public IVectorView<string> Keywords { get; }
+   public string Language { get; }
+   public Uri LinkUri { get; }
+   public StorePrice Price { get; }
+   public string ProductKind { get; }
+   public IVectorView<StoreSku> Skus { get; }
+   public string StoreId { get; }
+   public string Title { get; }
+   public IVectorView<StoreVideo> Videos { get; }
+   public IAsyncOperation<bool> GetIsAnySkuInstalledAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( StorePurchaseProperties operation );
+ }

+ public class Windows.Services.Store.StoreProductPagedQueryResult {
+   public HResult ExtendedError { get; }
+   public bool HasMoreResults { get; }
+   public IMapView<string, StoreProduct> Products { get; }
+   public IAsyncOperation<StoreProductPagedQueryResult> GetNextAsync();
+ }

+ public class Windows.Services.Store.StoreProductQueryResult {
+   public HResult ExtendedError { get; }
+   public IMapView<string, StoreProduct> Products { get; }
+ }

+ public class Windows.Services.Store.StoreProductResult {
+   public HResult ExtendedError { get; }
+   public StoreProduct Product { get; }
+ }

+ public class Windows.Services.Store.StorePurchaseProperties {
+   public string Name { get; set; }
+   public string ExtendedJsonData { get; set; }
+   public StorePurchaseProperties( string name );
+   public StorePurchaseProperties();
+ }

+ public class Windows.Services.Store.StorePurchaseResult {
+   public HResult ExtendedError { get; }
+   public StorePurchaseStatus Status { get; }
+ }

+ public enum Windows.Services.Store.StorePurchaseStatus {
+   Succeeded = 0,
+   AlreadyPurchased = 1,
+   NotPurchased = 2,
+   NetworkError = 3,
+   ServerError = 4,
+ }

+ public class Windows.Services.Store.StoreRequestHelper {
+   public static IAsyncOperation<StoreSendRequestResult> SendRequestAsync( StoreContext operation, uint context, string requestKind );
+ }

+ public class Windows.Services.Store.StoreSendRequestResult {
+   public HResult ExtendedError { get; }
+   public string Response { get; }
+ }

+ public class Windows.Services.Store.StoreSku {
+   public IVectorView<StoreAvailability> Availabilities { get; }
+   public IVectorView<string> BundledSkus { get; }
+   public StoreCollectionData CollectionData { get; }
+   public string CustomDeveloperData { get; }
+   public string Description { get; }
+   public string ExtendedJsonData { get; }
+   public IVectorView<StoreImage> Images { get; }
+   public bool IsInUserCollection { get; }
+   public bool IsSubscription { get; }
+   public bool IsTrial { get; }
+   public string Language { get; }
+   public StorePrice Price { get; }
+   public string StoreId { get; }
+   public StoreSubscriptionInfo SubscriptionInfo { get; }
+   public string Title { get; }
+   public IVectorView<StoreVideo> Videos { get; }
+   public IAsyncOperation<bool> GetIsInstalledAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync();
+   public IAsyncOperation<StorePurchaseResult> RequestPurchaseAsync( StorePurchaseProperties operation );
+ }

+ public class Windows.Services.Store.StoreSubscriptionInfo {
+   public uint BillingPeriod { get; }
+   public StoreDurationUnit BillingPeriodUnit { get; }
+   public bool HasTrialPeriod { get; }
+   public uint TrialPeriod { get; }
+   public StoreDurationUnit TrialPeriodUnit { get; }
+ }

+ public class Windows.Services.Store.StoreVideo {
+   public string Caption { get; }
+   public uint Height { get; }
+   public StoreImage PreviewImage { get; }
+   public Uri Uri { get; }
+   public string VideoPurposeTag { get; }
+   public uint Width { get; }
+ }

| public class Windows.Storage.StorageLibrary {
+   public StorageLibraryChangeTracker ChangeTracker { get; }
| }

+ public class Windows.Storage.StorageLibraryChange {
+   public StorageLibraryChangeType ChangeType { get; }
+   public string Path { get; }
+   public string PreviousPath { get; }
+   public bool IsOfType( StorageItemTypes value );
+   public IAsyncOperation<IStorageItem> GetStorageItemAsync();
+ }

+ public class Windows.Storage.StorageLibraryChangeReader {
+   public IAsyncOperation<IVectorView<StorageLibraryChange>> ReadBatchAsync();
+   public IAsyncAction AcceptChangesAsync();
+ }

+ public class Windows.Storage.StorageLibraryChangeTracker {
+   public StorageLibraryChangeReader GetChangeReader();
+   public void Enable();
+   public void Reset();
+ }

+ public enum Windows.Storage.StorageLibraryChangeType {
+   Created = 0,
+   Deleted = 1,
+   MovedOrRenamed = 2,
+   ContentsChanged = 3,
+   MovedOutOfLibrary = 4,
+   MovedIntoLibrary = 5,
+   ContentsReplaced = 6,
+   IndexingStatusChanged = 7,
+   EncryptionChanged = 8,
+   ChangeTrackingLost = 9,
+ }

| public enum Windows.System.AppMemoryUsageLevel {
+   OverLimit = 3,
| }

+ public enum Windows.System.LaunchFileStatus {
+   Success = 0,
+   AppUnavailable = 1,
+   DeniedByPolicy = 2,
+   FileTypeNotSupported = 3,
+   Unknown = 4,
+ }

| public class Windows.System.Launcher {
+   public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync( Uri operation );
+   public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync( Uri operation, string uri );
+   public static IAsyncOperation<IVectorView<AppInfo>> FindAppUriHandlersAsync( Uri operation );
+   public static IAsyncOperation<LaunchUriStatus> LaunchUriForUserAsync( User operation, Uri user );
+   public static IAsyncOperation<LaunchUriStatus> LaunchUriForUserAsync( User operation, Uri user, LauncherOptions uri );
+   public static IAsyncOperation<LaunchUriStatus> LaunchUriForUserAsync( User operation, Uri user, LauncherOptions uri, ValueSet options );
+   public static IAsyncOperation<LaunchUriResult> LaunchUriForResultsForUserAsync( User operation, Uri user, LauncherOptions uri );
+   public static IAsyncOperation<LaunchUriResult> LaunchUriForResultsForUserAsync( User operation, Uri user, LauncherOptions uri, ValueSet options );
| }

| public class Windows.System.LauncherOptions {
+   public bool IgnoreAppUriHandlers { get; set; }
| }

+ public enum Windows.System.RemoteLaunchUriStatus {
+   Unknown = 0,
+   Success = 1,
+   AppUnavailable = 2,
+   ProtocolUnavailable = 3,
+   RemoteSystemUnavailable = 4,
+   ValueSetTooLarge = 5,
+   DeniedByLocalSystem = 6,
+   DeniedByRemoteSystem = 7,
+ }

+ public class Windows.System.RemoteLauncher {
+   public static IAsyncOperation<RemoteLaunchUriStatus> LaunchUriAsync( RemoteSystemConnectionRequest operation, Uri remoteSystemConnectionRequest );
+   public static IAsyncOperation<RemoteLaunchUriStatus> LaunchUriAsync( RemoteSystemConnectionRequest operation, Uri remoteSystemConnectionRequest, RemoteLauncherOptions uri );
+   public static IAsyncOperation<RemoteLaunchUriStatus> LaunchUriAsync( RemoteSystemConnectionRequest operation, Uri remoteSystemConnectionRequest, RemoteLauncherOptions uri, ValueSet options );
+ }

+ public class Windows.System.RemoteLauncherOptions {
+   public Uri FallbackUri { get; set; }
+   public IVector<string> PreferredAppIds { get; }
+   public RemoteLauncherOptions();
+ }

+ public class Windows.System.UserDeviceAssociation {
+   public static User FindUserFromDeviceId( string user );
+   EventHandler<UserDeviceAssociationChangedEventArgs> UserDeviceAssociationChanged;
+ }

+ public class Windows.System.UserDeviceAssociationChangedEventArgs {
+   public string DeviceId { get; }
+   public User NewUser { get; }
+   public User OldUser { get; }
+ }

+ public class Windows.System.UserPicker {
+   public User SuggestedSelectedUser { get; set; }
+   public bool AllowGuestAccounts { get; set; }
+   public UserPicker();
+   public IAsyncOperation<User> PickSingleUserAsync();
+   public static bool IsSupported();
+ }

+ public struct Windows.System.Profile.ProfileSharedModeContract {
+ }

+ public class Windows.System.Profile.SharedModeSettings {
+   public bool IsEnabled { get; }
+ }

+ public class Windows.System.Profile.SystemIdentification {
+   public static SystemIdentificationInfo GetSystemIdForPublisher();
+   public static SystemIdentificationInfo GetSystemIdForUser( User result );
+ }

+ public class Windows.System.Profile.SystemIdentificationInfo {
+   public IBuffer Id { get; }
+   public SystemIdentificationSource Source { get; }
+ }

+ public enum Windows.System.Profile.SystemIdentificationSource {
+   None = 0,
+   Tpm = 1,
+   Uefi = 2,
+ }

+ public interface Windows.System.RemoteSystems.IRemoteSystemFilter {
+ }

+ public class Windows.System.RemoteSystems.RemoteSystem {
+   public string DisplayName { get; }
+   public string Id { get; }
+   public bool IsAvailableByProximity { get; }
+   public string Kind { get; }
+   public RemoteSystemStatus Status { get; }
+   public static IAsyncOperation<RemoteSystem> FindByHostNameAsync( HostName operation );
+   public static RemoteSystemWatcher CreateWatcher();
+   public static RemoteSystemWatcher CreateWatcher( IIterable<IRemoteSystemFilter> result );
+   public static IAsyncOperation<RemoteSystemAccessStatus> RequestAccessAsync();
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemAccessStatus {
+   Unspecified = 0,
+   Allowed = 1,
+   DeniedByUser = 2,
+   DeniedBySystem = 3,
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemAddedEventArgs {
+   public RemoteSystem RemoteSystem { get; }
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemConnectionRequest {
+   public RemoteSystem RemoteSystem { get; }
+   public RemoteSystemConnectionRequest( RemoteSystem remoteSystem );
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemDiscoveryType {
+   Any = 0,
+   Proximal = 1,
+   Cloud = 2,
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemDiscoveryTypeFilter {
+   public RemoteSystemDiscoveryType RemoteSystemDiscoveryType { get; }
+   public RemoteSystemDiscoveryTypeFilter( RemoteSystemDiscoveryType discoveryType );
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemKindFilter {
+   public IVectorView<string> RemoteSystemKinds { get; }
+   public RemoteSystemKindFilter( IIterable<string> remoteSystemKinds );
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemKinds {
+   public string Desktop { get; }
+   public string Holographic { get; }
+   public string Hub { get; }
+   public string Phone { get; }
+   public string Xbox { get; }
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs {
+   public string RemoteSystemId { get; }
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemStatus {
+   Unavailable = 0,
+   DiscoveringAvailability = 1,
+   Available = 2,
+   Unknown = 3,
+ }

+ public enum Windows.System.RemoteSystems.RemoteSystemStatusType {
+   Any = 0,
+   Available = 1,
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemStatusTypeFilter {
+   public RemoteSystemStatusType RemoteSystemStatusType { get; }
+   public RemoteSystemStatusTypeFilter( RemoteSystemStatusType remoteSystemStatusType );
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs {
+   public RemoteSystem RemoteSystem { get; }
+ }

+ public class Windows.System.RemoteSystems.RemoteSystemWatcher {
+   public void Start();
+   public void Stop();
+   TypedEventHandler<RemoteSystemWatcher, RemoteSystemAddedEventArgs> RemoteSystemAdded;
+   TypedEventHandler<RemoteSystemWatcher, RemoteSystemRemovedEventArgs> RemoteSystemRemoved;
+   TypedEventHandler<RemoteSystemWatcher, RemoteSystemUpdatedEventArgs> RemoteSystemUpdated;
+ }

| public class Windows.System.UserProfile.AdvertisingManager {
+   public static AdvertisingManagerForUser GetForUser( User value );
| }

+ public class Windows.System.UserProfile.AdvertisingManagerForUser {
+   public string AdvertisingId { get; }
+   public User User { get; }
+ }

| public class Windows.UI.ApplicationSettings.AccountsSettingsPane {
+   public static IAsyncAction ShowManageAccountsAsync();
+   public static IAsyncAction ShowAddAccountAsync();
| }

+ public class Windows.UI.Composition.AmbientLight : Windows.UI.Composition.CompositionLight {
+   public Color Color { get; set; }
+ }

+ public enum Windows.UI.Composition.AnimationDirection {
+   Normal = 0,
+   Reverse = 1,
+   Alternate = 2,
+   AlternateReverse = 3,
+ }

| public class Windows.UI.Composition.CompositionAnimation : Windows.UI.Composition.CompositionObject {
+   public string Target { get; set; }
+   public void SetBooleanParameter( string key, bool value );
| }

+ public class Windows.UI.Composition.CompositionAnimationGroup : Windows.UI.Composition.CompositionObject {
+   public int Count { get; }
+   public void Add( CompositionAnimation value );
+   public void Remove( CompositionAnimation value );
+   public void RemoveAll();
+   public IIterator<CompositionAnimation> First();
+ }

+ public class Windows.UI.Composition.CompositionBackdropBrush : Windows.UI.Composition.CompositionBrush {
+ }

| public class Windows.UI.Composition.CompositionClip : Windows.UI.Composition.CompositionObject {
+   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 Vector2 CenterPoint { get; set; }
+   public Vector2 AnchorPoint { get; set; }
| }

| public enum Windows.UI.Composition.CompositionCompositeMode {
+   MinBlend = 3,
| }

+ public class Windows.UI.Composition.CompositionLight : Windows.UI.Composition.CompositionObject {
+   public VisualUnorderedCollection Targets { get; }
+ }

+ public class Windows.UI.Composition.CompositionMaskBrush : Windows.UI.Composition.CompositionBrush {
+   public CompositionBrush Source { get; set; }
+   public CompositionBrush Mask { get; set; }
+ }

+ public class Windows.UI.Composition.CompositionNineGridBrush : Windows.UI.Composition.CompositionBrush {
+   public float TopInsetScale { get; set; }
+   public float TopInset { get; set; }
+   public CompositionBrush Source { get; set; }
+   public float RightInsetScale { get; set; }
+   public float RightInset { get; set; }
+   public float LeftInsetScale { get; set; }
+   public float LeftInset { get; set; }
+   public bool IsCenterHollow { get; set; }
+   public float BottomInsetScale { get; set; }
+   public float BottomInset { get; set; }
+   public void SetInsets( float inset );
+   public void SetInsets( float left, float top, float right, float bottom );
+   public void SetInsetScales( float scale );
+   public void SetInsetScales( float left, float top, float right, float bottom );
+ }

| public class Windows.UI.Composition.CompositionObject {
+   public ImplicitAnimationCollection ImplicitAnimations { get; set; }
+   public string Comment { get; set; }
+   public void StartAnimationGroup( ICompositionAnimationBase value );
+   public void StopAnimationGroup( ICompositionAnimationBase value );
| }

| public class Windows.UI.Composition.CompositionPropertySet : Windows.UI.Composition.CompositionObject {
+   public void InsertBoolean( string propertyName, bool value );
+   public CompositionGetValueStatus TryGetBoolean( string result, ref bool propertyName );
| }

+ public class Windows.UI.Composition.CompositionShadow : Windows.UI.Composition.CompositionObject {
+ }

| public class Windows.UI.Composition.CompositionSurfaceBrush : Windows.UI.Composition.CompositionBrush {
+   public Vector2 AnchorPoint { get; set; }
+   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 Vector2 CenterPoint { get; set; }
| }

| public class Windows.UI.Composition.Compositor {
+   public AmbientLight CreateAmbientLight();
+   public CompositionAnimationGroup CreateAnimationGroup();
+   public CompositionBackdropBrush CreateBackdropBrush();
+   public DistantLight CreateDistantLight();
+   public DropShadow CreateDropShadow();
+   public ImplicitAnimationCollection CreateImplicitAnimationCollection();
+   public LayerVisual CreateLayerVisual();
+   public CompositionMaskBrush CreateMaskBrush();
+   public CompositionNineGridBrush CreateNineGridBrush();
+   public PointLight CreatePointLight();
+   public SpotLight CreateSpotLight();
+   public StepEasingFunction CreateStepEasingFunction();
+   public StepEasingFunction CreateStepEasingFunction( int result );
| }

+ public class Windows.UI.Composition.DistantLight : Windows.UI.Composition.CompositionLight {
+   public Vector3 Direction { get; set; }
+   public Visual CoordinateSpace { get; set; }
+   public Color Color { get; set; }
+ }

+ public class Windows.UI.Composition.DropShadow : Windows.UI.Composition.CompositionShadow {
+   public float Opacity { get; set; }
+   public Vector3 Offset { get; set; }
+   public CompositionBrush Mask { get; set; }
+   public Color Color { get; set; }
+   public float BlurRadius { get; set; }
+ }

+ public interface Windows.UI.Composition.ICompositionAnimationBase {
+ }

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

| public class Windows.UI.Composition.KeyFrameAnimation : Windows.UI.Composition.CompositionAnimation {
+   public AnimationDirection Direction { get; set; }
| }

+ public class Windows.UI.Composition.LayerVisual : Windows.UI.Composition.ContainerVisual {
+   public CompositionEffectBrush Effect { get; set; }
+ }

+ public class Windows.UI.Composition.PointLight : Windows.UI.Composition.CompositionLight {
+   public float QuadraticAttenuation { get; set; }
+   public Vector3 Offset { get; set; }
+   public float LinearAttenuation { get; set; }
+   public Visual CoordinateSpace { get; set; }
+   public float ConstantAttenuation { get; set; }
+   public Color Color { get; set; }
+ }

+ public class Windows.UI.Composition.SpotLight : Windows.UI.Composition.CompositionLight {
+   public Color InnerConeColor { get; set; }
+   public float InnerConeAngleInDegrees { get; set; }
+   public float InnerConeAngle { get; set; }
+   public Vector3 Direction { get; set; }
+   public Visual CoordinateSpace { get; set; }
+   public float ConstantAttenuation { get; set; }
+   public float QuadraticAttenuation { get; set; }
+   public Color OuterConeColor { get; set; }
+   public float OuterConeAngleInDegrees { get; set; }
+   public float OuterConeAngle { get; set; }
+   public Vector3 Offset { get; set; }
+   public float LinearAttenuation { get; set; }
+ }

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

+ public class Windows.UI.Composition.StepEasingFunction : Windows.UI.Composition.CompositionEasingFunction {
+   public int StepCount { get; set; }
+   public bool IsInitialStepSingleFrame { get; set; }
+   public bool IsFinalStepSingleFrame { get; set; }
+   public int InitialStep { get; set; }
+   public int FinalStep { get; set; }
+ }

+ public class Windows.UI.Composition.VisualUnorderedCollection : Windows.UI.Composition.CompositionObject {
+   public int Count { get; }
+   public void Add( Visual newVisual );
+   public void Remove( Visual visual );
+   public void RemoveAll();
+   public IIterator<Visual> First();
+ }

+ public class Windows.UI.Composition.Effects.SceneLightingEffect {
+   public string Name { get; set; }
+   public float SpecularShine { get; set; }
+   public float SpecularAmount { get; set; }
+   public IGraphicsEffectSource NormalMapSource { get; set; }
+   public float DiffuseAmount { get; set; }
+   public float AmbientAmount { get; set; }
+   public SceneLightingEffect();
+ }

+ public class Windows.UI.Composition.Interactions.CompositionInteractionSourceCollection : Windows.UI.Composition.CompositionObject {
+   public int Count { get; }
+   public void Add( ICompositionInteractionSource value );
+   public void Remove( ICompositionInteractionSource value );
+   public void RemoveAll();
+   public IIterator<ICompositionInteractionSource> First();
+ }

+ public interface Windows.UI.Composition.Interactions.ICompositionInteractionSource {
+ }

+ public interface Windows.UI.Composition.Interactions.IInteractionTrackerOwner {
+   public void CustomAnimationStateEntered( InteractionTracker sender, InteractionTrackerCustomAnimationStateEnteredArgs args );
+   public void IdleStateEntered( InteractionTracker sender, InteractionTrackerIdleStateEnteredArgs args );
+   public void InertiaStateEntered( InteractionTracker sender, InteractionTrackerInertiaStateEnteredArgs args );
+   public void InteractingStateEntered( InteractionTracker sender, InteractionTrackerInteractingStateEnteredArgs args );
+   public void RequestIgnored( InteractionTracker sender, InteractionTrackerRequestIgnoredArgs args );
+   public void ValuesChanged( InteractionTracker sender, InteractionTrackerValuesChangedArgs args );
+ }

+ public enum Windows.UI.Composition.Interactions.InteractionChainingMode {
+   Auto = 0,
+   Always = 1,
+   Never = 2,
+ }

+ public enum Windows.UI.Composition.Interactions.InteractionSourceMode {
+   Disabled = 0,
+   EnabledWithInertia = 1,
+   EnabledWithoutInertia = 2,
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTracker : Windows.UI.Composition.CompositionObject {
+   public IReference<float> ScaleInertiaDecayRate { get; set; }
+   public IReference<Vector3> PositionInertiaDecayRate { get; set; }
+   public float MaxScale { get; set; }
+   public float MinScale { get; set; }
+   public Vector3 MaxPosition { get; set; }
+   public Vector3 MinPosition { get; set; }
+   public Vector3 NaturalRestingPosition { get; }
+   public float NaturalRestingScale { get; }
+   public IInteractionTrackerOwner Owner { get; }
+   public Vector3 Position { get; }
+   public CompositionInteractionSourceCollection InteractionSources { get; }
+   public Vector3 PositionVelocityInPixelsPerSecond { get; }
+   public float Scale { get; }
+   public bool IsPositionRoundingSuggested { get; }
+   public float ScaleVelocityInPercentPerSecond { get; }
+   public void AdjustPositionXIfGreaterThanThreshold( float adjustment, float positionThreshold );
+   public void AdjustPositionYIfGreaterThanThreshold( float adjustment, float positionThreshold );
+   public void ConfigurePositionXInertiaModifiers( IIterable<InteractionTrackerInertiaModifier> modifiers );
+   public void ConfigurePositionYInertiaModifiers( IIterable<InteractionTrackerInertiaModifier> modifiers );
+   public void ConfigureScaleInertiaModifiers( IIterable<InteractionTrackerInertiaModifier> modifiers );
+   public int TryUpdatePosition( Vector3 requestId );
+   public int TryUpdatePositionBy( Vector3 requestId );
+   public int TryUpdatePositionWithAnimation( CompositionAnimation requestId );
+   public int TryUpdatePositionWithAdditionalVelocity( Vector3 requestId );
+   public int TryUpdateScale( float requestId, Vector3 value );
+   public int TryUpdateScaleWithAnimation( CompositionAnimation requestId, Vector3 animation );
+   public int TryUpdateScaleWithAdditionalVelocity( float requestId, Vector3 velocityInPercentPerSecond );
+   public static InteractionTracker Create( Compositor result );
+   public static InteractionTracker CreateWithOwner( Compositor result, IInteractionTrackerOwner compositor );
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerCustomAnimationStateEnteredArgs {
+   public int RequestId { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerIdleStateEnteredArgs {
+   public int RequestId { get; }
+ }

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

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

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

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInertiaStateEnteredArgs {
+   public IReference<Vector3> ModifiedRestingPosition { get; }
+   public IReference<float> ModifiedRestingScale { get; }
+   public Vector3 NaturalRestingPosition { get; }
+   public float NaturalRestingScale { get; }
+   public Vector3 PositionVelocityInPixelsPerSecond { get; }
+   public int RequestId { get; }
+   public float ScaleVelocityInPercentPerSecond { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerInteractingStateEnteredArgs {
+   public int RequestId { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerRequestIgnoredArgs {
+   public int RequestId { get; }
+ }

+ public class Windows.UI.Composition.Interactions.InteractionTrackerValuesChangedArgs {
+   public Vector3 Position { get; }
+   public int RequestId { get; }
+   public float Scale { get; }
+ }

+ public class Windows.UI.Composition.Interactions.VisualInteractionSource : Windows.UI.Composition.CompositionObject {
+   public InteractionSourceMode ScaleSourceMode { get; set; }
+   public InteractionChainingMode ScaleChainingMode { get; set; }
+   public InteractionSourceMode PositionYSourceMode { get; set; }
+   public InteractionChainingMode PositionYChainingMode { get; set; }
+   public InteractionSourceMode PositionXSourceMode { get; set; }
+   public InteractionChainingMode PositionXChainingMode { get; set; }
+   public VisualInteractionSourceRedirectionMode ManipulationRedirectionMode { get; set; }
+   public bool IsPositionYRailsEnabled { get; set; }
+   public bool IsPositionXRailsEnabled { get; set; }
+   public Visual Source { get; }
+   public void TryRedirectForManipulation( PointerPoint pointerPoint );
+   public static VisualInteractionSource Create( Visual result );
+ }

+ public enum Windows.UI.Composition.Interactions.VisualInteractionSourceRedirectionMode {
+   Off = 0,
+   CapableTouchpadOnly = 1,
+ }

| public class Windows.UI.Core.AcceleratorKeyEventArgs {
+   public string DeviceId { get; }
| }

+ public class Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs {
+   public Rect ClosestInteractiveBounds { get; set; }
+   public Point PointerPosition { get; }
+   public Rect SearchBounds { get; }
+ }

| public class Windows.UI.Core.CoreComponentInputSource {
+   public string GetCurrentKeyEventDeviceId();
| }

| public class Windows.UI.Core.CoreWindow {
+   public string GetCurrentKeyEventDeviceId();
| }

| public class Windows.UI.Core.KeyEventArgs {
+   public string DeviceId { get; }
| }

+ public class Windows.UI.Input.RadialController {
+   public bool UseAutomaticHapticFeedback { get; set; }
+   public double RotationResolutionInDegrees { get; set; }
+   public RadialControllerMenu Menu { get; }
+   public static bool IsSupported();
+   public static RadialController CreateForCurrentView();
+   TypedEventHandler<RadialController, RadialControllerButtonClickedEventArgs> ButtonClicked;
+   TypedEventHandler<RadialController, RadialControllerControlAcquiredEventArgs> ControlAcquired;
+   TypedEventHandler<RadialController, object> ControlLost;
+   TypedEventHandler<RadialController, RadialControllerRotationChangedEventArgs> RotationChanged;
+   TypedEventHandler<RadialController, RadialControllerScreenContactContinuedEventArgs> ScreenContactContinued;
+   TypedEventHandler<RadialController, object> ScreenContactEnded;
+   TypedEventHandler<RadialController, RadialControllerScreenContactStartedEventArgs> ScreenContactStarted;
+ }

+ public class Windows.UI.Input.RadialControllerButtonClickedEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+ }

+ public class Windows.UI.Input.RadialControllerConfiguration {
+   public void SetDefaultMenuItems( IIterable<RadialControllerSystemMenuItemKind> buttons );
+   public void ResetToDefaultMenuItems();
+   public bool TrySelectDefaultMenuItem( RadialControllerSystemMenuItemKind result );
+   public static RadialControllerConfiguration GetForCurrentView();
+ }

+ public class Windows.UI.Input.RadialControllerControlAcquiredEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+ }

+ public class Windows.UI.Input.RadialControllerMenu {
+   public bool IsEnabled { get; set; }
+   public IVector<RadialControllerMenuItem> Items { get; }
+   public RadialControllerMenuItem GetSelectedMenuItem();
+   public void SelectMenuItem( RadialControllerMenuItem menuItem );
+   public bool TrySelectPreviouslySelectedMenuItem();
+ }

+ public class Windows.UI.Input.RadialControllerMenuItem {
+   public object Tag { get; set; }
+   public string DisplayText { get; }
+   public static RadialControllerMenuItem CreateFromIcon( string result, RandomAccessStreamReference displayText );
+   public static RadialControllerMenuItem CreateFromKnownIcon( string result, RadialControllerMenuKnownIcon displayText );
+   TypedEventHandler<RadialControllerMenuItem, object> Invoked;
+ }

+ public enum Windows.UI.Input.RadialControllerMenuKnownIcon {
+   Scroll = 0,
+   Zoom = 1,
+   UndoRedo = 2,
+   Volume = 3,
+   NextPreviousTrack = 4,
+   Ruler = 5,
+   InkColor = 6,
+   InkThickness = 7,
+   PenType = 8,
+ }

+ public class Windows.UI.Input.RadialControllerRotationChangedEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+   public double RotationDeltaInDegrees { get; }
+ }

+ public class Windows.UI.Input.RadialControllerScreenContact {
+   public Rect Bounds { get; }
+   public Point Position { get; }
+ }

+ public class Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+ }

+ public class Windows.UI.Input.RadialControllerScreenContactStartedEventArgs {
+   public RadialControllerScreenContact Contact { get; }
+ }

+ public enum Windows.UI.Input.RadialControllerSystemMenuItemKind {
+   Scroll = 0,
+   Zoom = 1,
+   UndoRedo = 2,
+   Volume = 3,
+   NextPreviousTrack = 4,
+ }

+ public interface Windows.UI.Input.Inking.IInkPresenterRulerFactory {
+   public InkPresenterRuler Create( InkPresenter inkPresenterRuler );
+ }

+ public interface Windows.UI.Input.Inking.IInkPresenterStencil {
+   public Color BackgroundColor { get; set; }
+   public Color ForegroundColor { get; set; }
+   public bool IsVisible { get; set; }
+   public InkPresenterStencilKind Kind { get; }
+   public Matrix3x2 Transform { get; set; }
+ }

| public class Windows.UI.Input.Inking.InkDrawingAttributes {
+   public InkDrawingAttributesKind Kind { get; }
+   public InkDrawingAttributesPencilProperties PencilProperties { get; }
+   public static InkDrawingAttributes CreateForPencil();
| }

+ public enum Windows.UI.Input.Inking.InkDrawingAttributesKind {
+   Default = 0,
+   Pencil = 1,
+ }

+ public class Windows.UI.Input.Inking.InkDrawingAttributesPencilProperties {
+   public double Opacity { get; set; }
+ }

+ public class Windows.UI.Input.Inking.InkPresenterRuler {
+   public double Width { get; set; }
+   public double Length { get; set; }
+   public Matrix3x2 Transform { get; set; }
+   public bool IsVisible { get; set; }
+   public Color ForegroundColor { get; set; }
+   public Color BackgroundColor { get; set; }
+   public InkPresenterStencilKind Kind { get; }
+   public InkPresenterRuler( InkPresenter inkPresenter );
+ }

+ public enum Windows.UI.Input.Inking.InkPresenterStencilKind {
+   Other = 0,
+   Ruler = 1,
+ }

+ public enum Windows.UI.Input.Inking.Core.CoreWetStrokeDisposition {
+   Inking = 0,
+   Completed = 1,
+   Canceled = 2,
+ }

+ public class Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs {
+   public CoreWetStrokeDisposition Disposition { get; set; }
+   public IVector<InkPoint> NewInkPoints { get; }
+   public uint PointerId { get; }
+ }

+ public class Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource {
+   public InkPresenter InkPresenter { get; }
+   public static CoreWetStrokeUpdateSource Create( InkPresenter WetStrokeUpdateSource );
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeCanceled;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeCompleted;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeContinuing;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeStarting;
+   TypedEventHandler<CoreWetStrokeUpdateSource, CoreWetStrokeUpdateEventArgs> WetStrokeStopping;
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputButtonChangeKind {
+   None = 0,
+   FirstButtonDown = 1,
+   FirstButtonUp = 2,
+   SecondButtonDown = 3,
+   SecondButtonUp = 4,
+   ThirdButtonDown = 5,
+   ThirdButtonUp = 6,
+   FourthButtonDown = 7,
+   FourthButtonUp = 8,
+   FifthButtonDown = 9,
+   FifthButtonUp = 10,
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputKeyOptions {
+   None = 0,
+   ExtendedKey = 1,
+   KeyUp = 2,
+   ScanCode = 8,
+   Unicode = 4,
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo {
+   public ushort VirtualKey { get; set; }
+   public ushort ScanCode { get; set; }
+   public InjectedInputKeyOptions KeyOptions { get; set; }
+   public InjectedInputKeyboardInfo();
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo {
+   public uint TimeOffsetInMilliseconds { get; set; }
+   public InjectedInputMouseOptions MouseOptions { get; set; }
+   public uint MouseData { get; set; }
+   public int DeltaY { get; set; }
+   public int DeltaX { get; set; }
+   public InjectedInputMouseInfo();
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputMouseOptions {
+   None = 0,
+   Move = 1,
+   LeftDown = 2,
+   LeftUp = 4,
+   RightDown = 8,
+   RightUp = 16,
+   MiddleDown = 32,
+   MiddleUp = 64,
+   XDown = 128,
+   XUp = 256,
+   Wheel = 2048,
+   HWheel = 4096,
+   MoveNoCoalesce = 8192,
+   VirtualDesk = 16384,
+   Absolute = 32768,
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputPenButtons {
+   None = 0,
+   Barrel = 1,
+   Inverted = 2,
+   Eraser = 4,
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputPenInfo {
+   public int TiltY { get; set; }
+   public int TiltX { get; set; }
+   public double Rotation { get; set; }
+   public double Pressure { get; set; }
+   public InjectedInputPointerInfo PointerInfo { get; set; }
+   public InjectedInputPenParameters PenParameters { get; set; }
+   public InjectedInputPenButtons PenButtons { get; set; }
+   public InjectedInputPenInfo();
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputPenParameters {
+   None = 0,
+   Pressure = 1,
+   Rotation = 2,
+   TiltX = 4,
+   TiltY = 8,
+ }

+ public struct Windows.UI.Input.Preview.Injection.InjectedInputPoint {
+   public int PositionX;
+   public int PositionY;
+ }

+ public struct Windows.UI.Input.Preview.Injection.InjectedInputPointerInfo {
+   public uint PointerId;
+   public InjectedInputPointerOptions PointerOptions;
+   public InjectedInputPoint PixelLocation;
+   public uint TimeOffsetInMilliseconds;
+   public ulong PerformanceCount;
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputPointerOptions {
+   None = 0,
+   New = 1,
+   InRange = 2,
+   InContact = 4,
+   FirstButton = 16,
+   SecondButton = 32,
+   Primary = 8192,
+   Confidence = 16384,
+   Canceled = 32768,
+   PointerDown = 65536,
+   Update = 131072,
+   PointerUp = 262144,
+   CaptureChanged = 2097152,
+ }

+ public struct Windows.UI.Input.Preview.Injection.InjectedInputRectangle {
+   public int Left;
+   public int Top;
+   public int Bottom;
+   public int Right;
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputShortcut {
+   Back = 0,
+   Start = 1,
+   Search = 2,
+ }

+ public class Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo {
+   public InjectedInputTouchParameters TouchParameters { get; set; }
+   public double Pressure { get; set; }
+   public InjectedInputPointerInfo PointerInfo { get; set; }
+   public int Orientation { get; set; }
+   public InjectedInputRectangle Contact { get; set; }
+   public InjectedInputTouchInfo();
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputTouchParameters {
+   None = 0,
+   Contact = 1,
+   Orientation = 2,
+   Pressure = 4,
+ }

+ public enum Windows.UI.Input.Preview.Injection.InjectedInputVisualizationMode {
+   None = 0,
+   Default = 1,
+   Indirect = 2,
+ }

+ public class Windows.UI.Input.Preview.Injection.InputInjector {
+   public void InjectKeyboardInput( IIterable<InjectedInputKeyboardInfo> input );
+   public void InjectMouseInput( IIterable<InjectedInputMouseInfo> input );
+   public void InitializeTouchInjection( InjectedInputVisualizationMode visualMode );
+   public void InjectTouchInput( IIterable<InjectedInputTouchInfo> input );
+   public void UninitializeTouchInjection();
+   public void InitializePenInjection( InjectedInputVisualizationMode visualMode );
+   public void InjectPenInput( InjectedInputPenInfo input );
+   public void UninitializePenInjection();
+   public void InjectShortcut( InjectedInputShortcut shortcut );
+   public static InputInjector TryCreate();
+ }

| public class Windows.UI.Input.Spatial.SpatialInteractionSourceLocation {
+   public IReference<Quaternion> Orientation { get; }
| }

+ public enum Windows.UI.Notifications.AdaptiveNotificationContentKind {
+   Text = 0,
+ }

+ public class Windows.UI.Notifications.AdaptiveNotificationText {
+   public IMap<string, string> Hints { get; }
+   public AdaptiveNotificationContentKind Kind { get; }
+   public string Text { get; set; }
+   public string Language { get; set; }
+   public AdaptiveNotificationText();
+ }

| public class Windows.UI.Notifications.BadgeUpdateManager {
+   public static BadgeUpdateManagerForUser GetForUser( User result );
| }

+ public class Windows.UI.Notifications.BadgeUpdateManagerForUser {
+   public User User { get; }
+   public BadgeUpdater CreateBadgeUpdaterForApplication();
+   public BadgeUpdater CreateBadgeUpdaterForApplication( string result );
+   public BadgeUpdater CreateBadgeUpdaterForSecondaryTile( string result );
+ }

+ public interface Windows.UI.Notifications.IAdaptiveNotificationContent {
+   public IMap<string, string> Hints { get; }
+   public AdaptiveNotificationContentKind Kind { get; }
+ }

+ public class Windows.UI.Notifications.KnownAdaptiveNotificationHints {
+   public string Align { get; }
+   public string MaxLines { get; }
+   public string MinLines { get; }
+   public string Style { get; }
+   public string TextStacking { get; }
+   public string Wrap { get; }
+ }

+ public class Windows.UI.Notifications.KnownAdaptiveNotificationTextStyles {
+   public string Base { get; }
+   public string BaseSubtle { get; }
+   public string Body { get; }
+   public string BodySubtle { get; }
+   public string Caption { get; }
+   public string CaptionSubtle { get; }
+   public string Header { get; }
+   public string HeaderNumeral { get; }
+   public string HeaderNumeralSubtle { get; }
+   public string HeaderSubtle { get; }
+   public string Subheader { get; }
+   public string SubheaderNumeral { get; }
+   public string SubheaderNumeralSubtle { get; }
+   public string SubheaderSubtle { get; }
+   public string Subtitle { get; }
+   public string SubtitleSubtle { get; }
+   public string Title { get; }
+   public string TitleNumeral { get; }
+   public string TitleSubtle { get; }
+ }

+ public class Windows.UI.Notifications.KnownNotificationBindings {
+   public string ToastGeneric { get; }
+ }

+ public class Windows.UI.Notifications.Notification {
+   public NotificationVisual Visual { get; set; }
+   public IReference<DateTime> ExpirationTime { get; set; }
+   public Notification();
+ }

+ public class Windows.UI.Notifications.NotificationBinding {
+   public string Template { get; set; }
+   public string Language { get; set; }
+   public IMap<string, string> Hints { get; }
+   public IVectorView<AdaptiveNotificationText> GetTextElements();
+ }

+ public enum Windows.UI.Notifications.NotificationKinds {
+   Unknown = 0,
+   Toast = 1,
+ }

+ public enum Windows.UI.Notifications.NotificationMirroring {
+   Allowed = 0,
+   Disabled = 1,
+ }

+ public class Windows.UI.Notifications.NotificationVisual {
+   public string Language { get; set; }
+   public IVector<NotificationBinding> Bindings { get; }
+   public NotificationBinding GetBinding( string result );
+ }

| public class Windows.UI.Notifications.ScheduledToastNotification {
+   public string RemoteId { get; set; }
+   public NotificationMirroring NotificationMirroring { get; set; }
| }

+ public class Windows.UI.Notifications.ShownTileNotification {
+   public string Arguments { get; }
+ }

| public class Windows.UI.Notifications.TileUpdateManager {
+   public static TileUpdateManagerForUser GetForUser( User result );
| }

+ public class Windows.UI.Notifications.TileUpdateManagerForUser {
+   public User User { get; }
+   public TileUpdater CreateTileUpdaterForApplicationForUser();
+   public TileUpdater CreateTileUpdaterForApplication( string updater );
+   public TileUpdater CreateTileUpdaterForSecondaryTile( string updater );
+ }

| public class Windows.UI.Notifications.ToastNotification {
+   public string RemoteId { get; set; }
+   public NotificationMirroring NotificationMirroring { get; set; }
| }

| public class Windows.UI.Notifications.ToastNotificationManager {
+   public static ToastNotificationManagerForUser GetForUser( User result );
+   public static void ConfigureNotificationMirroring( NotificationMirroring value );
| }

+ public class Windows.UI.Notifications.ToastNotificationManagerForUser {
+   public ToastNotificationHistory History { get; }
+   public User User { get; }
+   public ToastNotifier CreateToastNotifier();
+   public ToastNotifier CreateToastNotifier( string result );
+ }

+ public class Windows.UI.Notifications.UserNotification {
+   public AppInfo AppInfo { get; }
+   public DateTime CreationTime { get; }
+   public uint Id { get; }
+   public Notification Notification { get; }
+ }

+ public class Windows.UI.Notifications.UserNotificationChangedEventArgs {
+   public UserNotificationChangedKind ChangeKind { get; }
+   public uint UserNotificationId { get; }
+ }

+ public enum Windows.UI.Notifications.UserNotificationChangedKind {
+   Added = 0,
+   Removed = 1,
+ }

+ public class Windows.UI.Notifications.Management.UserNotificationListener {
+   public UserNotificationListener Current { get; }
+   public IAsyncOperation<UserNotificationListenerAccessStatus> RequestAccessAsync();
+   public UserNotificationListenerAccessStatus GetAccessStatus();
+   public IAsyncOperation<IVectorView<UserNotification>> GetNotificationsAsync( NotificationKinds result );
+   public UserNotification GetNotification( uint result );
+   public void ClearNotifications();
+   public void RemoveNotification( uint notificationId );
+   TypedEventHandler<UserNotificationListener, UserNotificationChangedEventArgs> NotificationChanged;
+ }

+ public enum Windows.UI.Notifications.Management.UserNotificationListenerAccessStatus {
+   Unspecified = 0,
+   Allowed = 1,
+   Denied = 2,
+ }

| public enum Windows.UI.Text.Core.CoreTextInputScope {
+   ChatWithoutEmoji = 68,
| }

+ public class Windows.UI.ViewManagement.ApplicationViewScaling {
+   public bool DisableLayoutScaling { get; }
+   public static bool TrySetDisableLayoutScaling( bool success );
+ }

+ public struct Windows.UI.ViewManagement.ViewManagementViewScalingContract {
+ }

+ public class Windows.UI.WebUI.EnteredBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public void delegate Windows.UI.WebUI.EnteredBackgroundEventHandler( object sender, IEnteredBackgroundEventArgs e );

+ public class Windows.UI.WebUI.LeavingBackgroundEventArgs {
+   public Deferral GetDeferral();
+ }

+ public void delegate Windows.UI.WebUI.LeavingBackgroundEventHandler( object sender, ILeavingBackgroundEventArgs e );

| public class Windows.UI.WebUI.WebUIApplication {
+   public static void EnablePrelaunch( bool value );
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderAddAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderRemoveAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderReplaceAppointmentActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIAppointmentsProviderShowTimeFrameActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUICachedFileUpdaterActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIDeviceActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIDevicePairingActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIDialReceiverActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileOpenPickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileOpenPickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileSavePickerActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFileSavePickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIFolderPickerContinuationEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUILaunchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUILockScreenActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIProtocolActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIProtocolForResultsActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIRestrictedLaunchActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIShareTargetActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIToastNotificationActivatedEventArgs {
+   public User User { get; }
| }

+ public class Windows.UI.WebUI.WebUIUserDataAccountProviderActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public IUserDataAccountProviderOperation Operation { get; }
+   public ActivatedOperation ActivatedOperation { get; }
+ }

| public class Windows.UI.WebUI.WebUIVoiceCommandActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.WebUI.WebUIWebAccountProviderActivatedEventArgs {
+   public User User { get; }
| }

| public class Windows.UI.Xaml.Application {
+   public ApplicationRequiresPointerMode RequiresPointerMode { get; set; }
+   public FocusVisualKind FocusVisualKind { get; set; }
| }

+ public enum Windows.UI.Xaml.ApplicationRequiresPointerMode {
+   Auto = 0,
+   WhenRequested = 1,
+ }

| public class Windows.UI.Xaml.DragEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public DataPackageOperation AllowedOperations { get; }
| }

| public class Windows.UI.Xaml.DragStartingEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public DataPackageOperation AllowedOperations { get; set; }
| }

+ public enum Windows.UI.Xaml.ElementSoundKind {
+   Focus = 0,
+   Invoke = 1,
+   Show = 2,
+   Hide = 3,
+   MovePrevious = 4,
+   MoveNext = 5,
+   GoBack = 6,
+ }

+ public enum Windows.UI.Xaml.ElementSoundMode {
+   Default = 0,
+   FocusOnly = 1,
+   Off = 2,
+ }

+ public class Windows.UI.Xaml.ElementSoundPlayer {
+   public double Volume { get; set; }
+   public ElementSoundPlayerState State { get; set; }
+   public static void Play( ElementSoundKind sound );
+ }

+ public enum Windows.UI.Xaml.ElementSoundPlayerState {
+   Auto = 0,
+   Off = 1,
+   On = 2,
+ }

+ public void delegate Windows.UI.Xaml.EnteredBackgroundEventHandler( object sender, EnteredBackgroundEventArgs e );

+ public enum Windows.UI.Xaml.FocusVisualKind {
+   DottedLine = 0,
+   HighVisibility = 1,
+ }

| public class Windows.UI.Xaml.FrameworkElement : Windows.UI.Xaml.UIElement {
+   public Thickness FocusVisualMargin { get; set; }
+   public Brush FocusVisualSecondaryBrush { get; set; }
+   public Thickness FocusVisualPrimaryThickness { get; set; }
+   public Brush FocusVisualPrimaryBrush { get; set; }
+   public bool AllowFocusWhenDisabled { get; set; }
+   public bool AllowFocusOnInteraction { get; set; }
+   public Thickness FocusVisualSecondaryThickness { get; set; }
+   public DependencyProperty AllowFocusOnInteractionProperty { get; }
+   public DependencyProperty AllowFocusWhenDisabledProperty { get; }
+   public DependencyProperty FocusVisualMarginProperty { get; }
+   public DependencyProperty FocusVisualPrimaryBrushProperty { get; }
+   public DependencyProperty FocusVisualPrimaryThicknessProperty { get; }
+   public DependencyProperty FocusVisualSecondaryBrushProperty { get; }
+   public DependencyProperty FocusVisualSecondaryThicknessProperty { get; }
| }

+ public void delegate Windows.UI.Xaml.LeavingBackgroundEventHandler( object sender, LeavingBackgroundEventArgs e );

| public class Windows.UI.Xaml.UIElement : Windows.UI.Xaml.DependencyObject {
+   public bool IsAccessKeyScope { get; set; }
+   public bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
+   public FlyoutBase ContextFlyout { get; set; }
+   public DependencyObject AccessKeyScopeOwner { get; set; }
+   public string AccessKey { get; set; }
+   public DependencyProperty AccessKeyScopeOwnerProperty { get; }
+   public DependencyProperty ContextFlyoutProperty { get; }
+   public DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
+   public DependencyProperty IsAccessKeyScopeProperty { get; }
+   public DependencyProperty AccessKeyProperty { get; }
| }

| public enum Windows.UI.Xaml.Automation.AnnotationType {
+   InsertionChange = 60011,
+   DeletionChange = 60012,
+   MoveChange = 60013,
+   FormatChange = 60014,
+   UnsyncedChange = 60015,
+   EditingLockedChange = 60016,
+   ExternalChange = 60017,
+   ConflictingChange = 60018,
+   Author = 60019,
+   AdvancedProofingIssue = 60020,
+   DataValidationError = 60021,
+   CircularReferenceError = 60022,
| }

| public class Windows.UI.Xaml.Automation.AutomationElementIdentifiers {
+   public AutomationProperty FlowsFromProperty { get; }
+   public AutomationProperty FlowsToProperty { get; }
+   public AutomationProperty IsPeripheralProperty { get; }
+   public AutomationProperty IsDataValidForFormProperty { get; }
+   public AutomationProperty FullDescriptionProperty { get; }
+   public AutomationProperty DescribedByProperty { get; }
| }

| public class Windows.UI.Xaml.Automation.AutomationProperties {
+   public DependencyProperty LocalizedControlTypeProperty { get; }
+   public DependencyProperty IsPeripheralProperty { get; }
+   public DependencyProperty IsDataValidForFormProperty { get; }
+   public DependencyProperty FullDescriptionProperty { get; }
+   public DependencyProperty FlowsToProperty { get; }
+   public DependencyProperty FlowsFromProperty { get; }
+   public DependencyProperty DescribedByProperty { get; }
+   public static bool GetIsPeripheral( DependencyObject value );
+   public static void SetIsPeripheral( DependencyObject element, bool value );
+   public static bool GetIsDataValidForForm( DependencyObject value );
+   public static void SetIsDataValidForForm( DependencyObject element, bool value );
+   public static string GetFullDescription( DependencyObject value );
+   public static void SetFullDescription( DependencyObject element, string value );
+   public static string GetLocalizedControlType( DependencyObject value );
+   public static void SetLocalizedControlType( DependencyObject element, string value );
+   public static IVector<DependencyObject> GetDescribedBy( DependencyObject value );
+   public static IVector<DependencyObject> GetFlowsTo( DependencyObject value );
+   public static IVector<DependencyObject> GetFlowsFrom( DependencyObject value );
| }

| public class Windows.UI.Xaml.Automation.Peers.AppBarAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+   public WindowInteractionState InteractionState { get; }
+   public bool IsModal { get; }
+   public bool IsTopmost { get; }
+   public bool Maximizable { get; }
+   public bool Minimizable { get; }
+   public WindowVisualState VisualState { get; }
+   public void Close();
+   public void SetVisualState( WindowVisualState state );
+   public bool WaitForInputIdle( int returnValue );
| }

| public enum Windows.UI.Xaml.Automation.Peers.AutomationEvents {
+   LayoutInvalidated = 29,
| }

| public class Windows.UI.Xaml.Automation.Peers.AutomationPeer : Windows.UI.Xaml.DependencyObject {
+   public bool IsPeripheral();
+   public bool IsDataValidForForm();
+   public string GetFullDescription();
| }

| public class Windows.UI.Xaml.Automation.Peers.ComboBoxAutomationPeer : Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer {
+   public WindowInteractionState InteractionState { get; }
+   public bool IsModal { get; }
+   public bool IsTopmost { get; }
+   public bool Maximizable { get; }
+   public bool Minimizable { get; }
+   public WindowVisualState VisualState { get; }
+   public void Close();
+   public void SetVisualState( WindowVisualState state );
+   public bool WaitForInputIdle( int returnValue );
| }

+ public class Windows.UI.Xaml.Automation.Peers.InkToolbarAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+ }

| public class Windows.UI.Xaml.Automation.Peers.MapControlAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+   public double HorizontalScrollPercent { get; }
+   public double HorizontalViewSize { get; }
+   public bool HorizontallyScrollable { get; }
+   public double VerticalScrollPercent { get; }
+   public double VerticalViewSize { get; }
+   public bool VerticallyScrollable { get; }
+   public void Scroll( ScrollAmount horizontalAmount, ScrollAmount verticalAmount );
+   public void SetScrollPercent( double horizontalPercent, double verticalPercent );
| }

+ public class Windows.UI.Xaml.Automation.Peers.MediaPlayerElementAutomationPeer : Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer {
+   public MediaPlayerElementAutomationPeer( MediaPlayerElement owner );
+ }

| public class Windows.UI.Xaml.Controls.AppBar : Windows.UI.Xaml.Controls.ContentControl {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AppBarButton : Windows.UI.Xaml.Controls.Button {
+   public CommandBarLabelPosition LabelPosition { get; set; }
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+   public DependencyProperty DynamicOverflowOrderProperty { get; }
+   public DependencyProperty IsInOverflowProperty { get; }
+   public DependencyProperty LabelPositionProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AppBarSeparator : Windows.UI.Xaml.Controls.Control {
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+   public DependencyProperty DynamicOverflowOrderProperty { get; }
+   public DependencyProperty IsInOverflowProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AppBarToggleButton : Windows.UI.Xaml.Controls.Primitives.ToggleButton {
+   public CommandBarLabelPosition LabelPosition { get; set; }
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+   public DependencyProperty DynamicOverflowOrderProperty { get; }
+   public DependencyProperty IsInOverflowProperty { get; }
+   public DependencyProperty LabelPositionProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.AutoSuggestBox : Windows.UI.Xaml.Controls.ItemsControl {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.CalendarDatePicker : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.ComboBox : Windows.UI.Xaml.Controls.Primitives.Selector {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public bool IsTextSearchEnabled { get; set; }
+   public DependencyProperty IsTextSearchEnabledProperty { get; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.CommandBar : Windows.UI.Xaml.Controls.AppBar {
+   public CommandBarOverflowButtonVisibility OverflowButtonVisibility { get; set; }
+   public bool IsDynamicOverflowEnabled { get; set; }
+   public CommandBarDefaultLabelPosition DefaultLabelPosition { get; set; }
+   public DependencyProperty DefaultLabelPositionProperty { get; }
+   public DependencyProperty IsDynamicOverflowEnabledProperty { get; }
+   public DependencyProperty OverflowButtonVisibilityProperty { get; }
| }

+ public enum Windows.UI.Xaml.Controls.CommandBarDefaultLabelPosition {
+   Bottom = 0,
+   Right = 1,
+   Collapsed = 2,
+ }

+ public enum Windows.UI.Xaml.Controls.CommandBarDynamicOverflowAction {
+   AddingToOverflow = 0,
+   RemovingFromOverflow = 1,
+ }

+ public enum Windows.UI.Xaml.Controls.CommandBarLabelPosition {
+   Default = 0,
+   Collapsed = 1,
+ }

+ public enum Windows.UI.Xaml.Controls.CommandBarOverflowButtonVisibility {
+   Auto = 0,
+   Visible = 1,
+   Collapsed = 2,
+ }

| public class Windows.UI.Xaml.Controls.Control : Windows.UI.Xaml.FrameworkElement {
+   public DependencyObject XYFocusRight { get; set; }
+   public bool IsFocusEngaged { get; set; }
+   public DependencyObject XYFocusLeft { get; set; }
+   public DependencyObject XYFocusDown { get; set; }
+   public RequiresPointer RequiresPointer { get; set; }
+   public bool IsFocusEngagementEnabled { get; set; }
+   public ElementSoundMode ElementSoundMode { get; set; }
+   public DependencyObject XYFocusUp { get; set; }
+   public DependencyProperty ElementSoundModeProperty { get; }
+   public DependencyProperty IsFocusEngagedProperty { get; }
+   public DependencyProperty IsFocusEngagementEnabledProperty { get; }
+   public DependencyProperty RequiresPointerProperty { get; }
+   public DependencyProperty XYFocusDownProperty { get; }
+   public DependencyProperty XYFocusLeftProperty { get; }
+   public DependencyProperty XYFocusRightProperty { get; }
+   public DependencyProperty XYFocusUpProperty { get; }
+   public void RemoveFocusEngagement();
| }

| public class Windows.UI.Xaml.Controls.DatePicker : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs {
+   public CommandBarDynamicOverflowAction Action { get; }
+   public DynamicOverflowItemsChangingEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.FocusDisengagedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ }

+ public class Windows.UI.Xaml.Controls.FocusEngagedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+ }

+ public interface Windows.UI.Xaml.Controls.ICommandBarElement2 {
+   public int DynamicOverflowOrder { get; set; }
+   public bool IsInOverflow { get; }
+ }

+ public interface Windows.UI.Xaml.Controls.IInsertionPanel {
+   public void GetInsertionIndexes( Point position, ref int first, ref int second );
+ }

| public class Windows.UI.Xaml.Controls.Image : Windows.UI.Xaml.FrameworkElement {
+   public CompositionBrush GetAlphaMask();
| }

+ public class Windows.UI.Xaml.Controls.InkToolbar : Windows.UI.Xaml.Controls.Control {
+   public InkCanvas TargetInkCanvas { get; set; }
+   public bool IsRulerButtonChecked { get; set; }
+   public InkToolbarInitialControls InitialControls { get; set; }
+   public InkToolbarToolButton ActiveTool { get; set; }
+   public DependencyObjectCollection Children { get; }
+   public InkDrawingAttributes InkDrawingAttributes { get; }
+   public DependencyProperty ActiveToolProperty { get; }
+   public DependencyProperty ChildrenProperty { get; }
+   public DependencyProperty InitialControlsProperty { get; }
+   public DependencyProperty InkDrawingAttributesProperty { get; }
+   public DependencyProperty IsRulerButtonCheckedProperty { get; }
+   public DependencyProperty TargetInkCanvasProperty { get; }
+   public InkToolbar();
+   public InkToolbarToolButton GetToolButton( InkToolbarTool returnValue );
+   public InkToolbarToggleButton GetToggleButton( InkToolbarToggle returnValue );
+   TypedEventHandler<InkToolbar, object> ActiveToolChanged;
+   TypedEventHandler<InkToolbar, object> EraseAllClicked;
+   TypedEventHandler<InkToolbar, object> InkDrawingAttributesChanged;
+   TypedEventHandler<InkToolbar, object> IsRulerButtonCheckedChanged;
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarBallpointPenButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarBallpointPenButton();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomPen : Windows.UI.Xaml.DependencyObject {
+   protected InkToolbarCustomPen();
+   public InkDrawingAttributes CreateInkDrawingAttributes( Brush returnValue, double brush );
+   protected InkDrawingAttributes CreateInkDrawingAttributesCore( Brush returnValue, double brush );
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomPenButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarCustomPen CustomPen { get; set; }
+   public UIElement ConfigurationContent { get; set; }
+   public DependencyProperty ConfigurationContentProperty { get; }
+   public DependencyProperty CustomPenProperty { get; }
+   public InkToolbarCustomPenButton();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomToggleButton : Windows.UI.Xaml.Controls.InkToolbarToggleButton {
+   public InkToolbarCustomToggleButton();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarCustomToolButton : Windows.UI.Xaml.Controls.InkToolbarToolButton {
+   public UIElement ConfigurationContent { get; set; }
+   public DependencyProperty ConfigurationContentProperty { get; }
+   public InkToolbarCustomToolButton();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarEraserButton : Windows.UI.Xaml.Controls.InkToolbarToolButton {
+   public InkToolbarEraserButton();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarHighlighterButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarHighlighterButton();
+ }

+ public enum Windows.UI.Xaml.Controls.InkToolbarInitialControls {
+   All = 0,
+   None = 1,
+   PensOnly = 2,
+   AllExceptPens = 3,
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarPenButton : Windows.UI.Xaml.Controls.InkToolbarToolButton {
+   public double SelectedStrokeWidth { get; set; }
+   public int SelectedBrushIndex { get; set; }
+   public IVector<Brush> Palette { get; set; }
+   public double MinStrokeWidth { get; set; }
+   public double MaxStrokeWidth { get; set; }
+   public Brush SelectedBrush { get; }
+   public DependencyProperty MaxStrokeWidthProperty { get; }
+   public DependencyProperty MinStrokeWidthProperty { get; }
+   public DependencyProperty PaletteProperty { get; }
+   public DependencyProperty SelectedBrushIndexProperty { get; }
+   public DependencyProperty SelectedBrushProperty { get; }
+   public DependencyProperty SelectedStrokeWidthProperty { get; }
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarPenConfigurationControl : Windows.UI.Xaml.Controls.Control {
+   public InkToolbarPenButton PenButton { get; }
+   public DependencyProperty PenButtonProperty { get; }
+   public InkToolbarPenConfigurationControl();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarPencilButton : Windows.UI.Xaml.Controls.InkToolbarPenButton {
+   public InkToolbarPencilButton();
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarRulerButton : Windows.UI.Xaml.Controls.InkToolbarToggleButton {
+   public InkPresenterRuler Ruler { get; }
+   public DependencyProperty RulerProperty { get; }
+   public InkToolbarRulerButton();
+ }

+ public enum Windows.UI.Xaml.Controls.InkToolbarToggle {
+   Ruler = 0,
+   Custom = 1,
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarToggleButton : Windows.UI.Xaml.Controls.CheckBox {
+   public InkToolbarToggle ToggleKind { get; }
+ }

+ public enum Windows.UI.Xaml.Controls.InkToolbarTool {
+   BallpointPen = 0,
+   Pencil = 1,
+   Highlighter = 2,
+   Eraser = 3,
+   CustomPen = 4,
+   CustomTool = 5,
+ }

+ public class Windows.UI.Xaml.Controls.InkToolbarToolButton : Windows.UI.Xaml.Controls.RadioButton {
+   public bool IsExtensionGlyphShown { get; set; }
+   public InkToolbarTool ToolKind { get; }
+   public DependencyProperty IsExtensionGlyphShownProperty { get; }
+ }

| public enum Windows.UI.Xaml.Controls.ItemsUpdatingScrollMode {
+   KeepLastItemInView = 2,
| }

+ public enum Windows.UI.Xaml.Controls.LightDismissOverlayMode {
+   Auto = 0,
+   On = 1,
+   Off = 2,
+ }

| public class Windows.UI.Xaml.Controls.ListBox : Windows.UI.Xaml.Controls.Primitives.Selector {
+   public bool SingleSelectionFollowsFocus { get; set; }
+   public DependencyProperty SingleSelectionFollowsFocusProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.ListViewBase : Windows.UI.Xaml.Controls.Primitives.Selector {
+   public bool SingleSelectionFollowsFocus { get; set; }
+   public DependencyProperty SingleSelectionFollowsFocusProperty { get; }
+   public bool IsDragSource();
| }

+ public class Windows.UI.Xaml.Controls.MediaPlayerElement : Windows.UI.Xaml.Controls.Control {
+   public MediaTransportControls TransportControls { get; set; }
+   public Stretch Stretch { get; set; }
+   public IMediaPlaybackSource Source { get; set; }
+   public ImageSource PosterSource { get; set; }
+   public bool IsFullWindow { get; set; }
+   public bool AutoPlay { get; set; }
+   public bool AreTransportControlsEnabled { get; set; }
+   public MediaPlayer MediaPlayer { get; }
+   public DependencyProperty AreTransportControlsEnabledProperty { get; }
+   public DependencyProperty AutoPlayProperty { get; }
+   public DependencyProperty IsFullWindowProperty { get; }
+   public DependencyProperty MediaPlayerProperty { get; }
+   public DependencyProperty PosterSourceProperty { get; }
+   public DependencyProperty SourceProperty { get; }
+   public DependencyProperty StretchProperty { get; }
+   public MediaPlayerElement();
+   public void SetMediaPlayer( MediaPlayer mediaPlayer );
+ }

+ public class Windows.UI.Xaml.Controls.MediaPlayerPresenter : Windows.UI.Xaml.FrameworkElement {
+   public Stretch Stretch { get; set; }
+   public MediaPlayer MediaPlayer { get; set; }
+   public bool IsFullWindow { get; set; }
+   public DependencyProperty IsFullWindowProperty { get; }
+   public DependencyProperty MediaPlayerProperty { get; }
+   public DependencyProperty StretchProperty { get; }
+   public MediaPlayerPresenter();
+ }

| public class Windows.UI.Xaml.Controls.MediaTransportControls : Windows.UI.Xaml.Controls.Control {
+   public bool IsSkipForwardEnabled { get; set; }
+   public FastPlayFallbackBehaviour FastPlayFallbackBehaviour { get; set; }
+   public bool IsSkipForwardButtonVisible { get; set; }
+   public bool IsSkipBackwardEnabled { get; set; }
+   public bool IsSkipBackwardButtonVisible { get; set; }
+   public bool IsPreviousTrackButtonVisible { get; set; }
+   public bool IsNextTrackButtonVisible { get; set; }
+   public DependencyProperty FastPlayFallbackBehaviourProperty { get; }
+   public DependencyProperty IsNextTrackButtonVisibleProperty { get; }
+   public DependencyProperty IsPreviousTrackButtonVisibleProperty { get; }
+   public DependencyProperty IsSkipBackwardButtonVisibleProperty { get; }
+   public DependencyProperty IsSkipBackwardEnabledProperty { get; }
+   public DependencyProperty IsSkipForwardButtonVisibleProperty { get; }
+   public DependencyProperty IsSkipForwardEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.Pivot : Windows.UI.Xaml.Controls.ItemsControl {
+   public bool IsHeaderItemsCarouselEnabled { get; set; }
+   public PivotHeaderFocusVisualPlacement HeaderFocusVisualPlacement { get; set; }
+   public DependencyProperty IsHeaderItemsCarouselEnabledProperty { get; }
+   public DependencyProperty HeaderFocusVisualPlacementProperty { get; }
| }

+ public enum Windows.UI.Xaml.Controls.PivotHeaderFocusVisualPlacement {
+   ItemHeaders = 0,
+   SelectedItemHeader = 1,
+ }

+ public enum Windows.UI.Xaml.Controls.RequiresPointer {
+   Never = 0,
+   WhenEngaged = 1,
+   WhenFocused = 2,
+ }

| public class Windows.UI.Xaml.Controls.SplitView : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.StackPanel : Windows.UI.Xaml.Controls.Panel {
+   public void GetInsertionIndexes( Point position, ref int first, ref int second );
| }

| public class Windows.UI.Xaml.Controls.TextBlock : Windows.UI.Xaml.FrameworkElement {
+   public CompositionBrush GetAlphaMask();
| }

| public class Windows.UI.Xaml.Controls.TimePicker : Windows.UI.Xaml.Controls.Control {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.WebView : Windows.UI.Xaml.FrameworkElement {
+   public DependencyObject XYFocusRight { get; set; }
+   public DependencyObject XYFocusLeft { get; set; }
+   public DependencyObject XYFocusDown { get; set; }
+   public DependencyObject XYFocusUp { get; set; }
+   public DependencyProperty XYFocusDownProperty { get; }
+   public DependencyProperty XYFocusLeftProperty { get; }
+   public DependencyProperty XYFocusRightProperty { get; }
+   public DependencyProperty XYFocusUpProperty { get; }
| }

| public enum Windows.UI.Xaml.Controls.WebViewPermissionType {
+   WebNotifications = 4,
| }

| public class Windows.UI.Xaml.Controls.Maps.MapControl : Windows.UI.Xaml.Controls.Control {
+   public bool BusinessLandmarksEnabled { get; set; }
+   public bool TransitFeaturesEnabled { get; set; }
+   public DependencyProperty TransitFeaturesEnabledProperty { get; }
+   public DependencyProperty BusinessLandmarksEnabledProperty { get; }
+   public Geopath GetVisibleRegion( MapVisibleRegionKind returnValue );
| }

+ public class Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs {
+   public IVectorView<LocalLocation> LocalLocations { get; }
+   public MapControlBusinessLandmarkPointerEnteredEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs {
+   public IVectorView<LocalLocation> LocalLocations { get; }
+   public MapControlBusinessLandmarkPointerExitedEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs {
+   public string DisplayName { get; }
+   public Geopoint Location { get; }
+   public IMapView<string, object> TransitProperties { get; }
+   public MapControlTransitFeaturePointerEnteredEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs {
+   public string DisplayName { get; }
+   public Geopoint Location { get; }
+   public IMapView<string, object> TransitProperties { get; }
+   public MapControlTransitFeaturePointerExitedEventArgs();
+ }

| public enum Windows.UI.Xaml.Controls.Maps.MapInteractionMode {
+   PointerAndKeyboard = 2,
+   PointerKeyboardAndControl = 4,
+   PointerOnly = 5,
| }

+ public enum Windows.UI.Xaml.Controls.Maps.MapVisibleRegionKind {
+   Near = 0,
+   Full = 1,
+ }

| public class Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings : Windows.UI.Xaml.DependencyObject {
+   public Visibility EffectiveOverflowButtonVisibility { get; }
| }

| public class Windows.UI.Xaml.Controls.Primitives.FlyoutBase : Windows.UI.Xaml.DependencyObject {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public ElementSoundMode ElementSoundMode { get; set; }
+   public bool AllowFocusWhenDisabled { get; set; }
+   public bool AllowFocusOnInteraction { get; set; }
+   public FrameworkElement Target { get; }
+   public DependencyProperty AllowFocusOnInteractionProperty { get; }
+   public DependencyProperty AllowFocusWhenDisabledProperty { get; }
+   public DependencyProperty ElementSoundModeProperty { get; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs {
+   public bool Cancel { get; set; }
+ }

| public class Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel : Windows.UI.Xaml.Controls.VirtualizingPanel {
+   public void GetInsertionIndexes( Point position, ref int first, ref int second );
| }

| public class Windows.UI.Xaml.Controls.Primitives.Popup : Windows.UI.Xaml.FrameworkElement {
+   public LightDismissOverlayMode LightDismissOverlayMode { get; set; }
+   public DependencyProperty LightDismissOverlayModeProperty { get; }
| }

| public class Windows.UI.Xaml.Documents.Hyperlink : Windows.UI.Xaml.Documents.Span {
+   public DependencyObject XYFocusUp { get; set; }
+   public DependencyObject XYFocusRight { get; set; }
+   public DependencyObject XYFocusLeft { get; set; }
+   public DependencyObject XYFocusDown { get; set; }
+   public ElementSoundMode ElementSoundMode { get; set; }
+   public DependencyProperty ElementSoundModeProperty { get; }
+   public DependencyProperty XYFocusDownProperty { get; }
+   public DependencyProperty XYFocusLeftProperty { get; }
+   public DependencyProperty XYFocusRightProperty { get; }
+   public DependencyProperty XYFocusUpProperty { get; }
| }

| public class Windows.UI.Xaml.Documents.TextElement : Windows.UI.Xaml.DependencyObject {
+   public string AccessKey { get; set; }
+   public bool AllowFocusOnInteraction { get; set; }
+   public bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
+   public DependencyProperty AllowFocusOnInteractionProperty { get; }
+   public DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
+   public DependencyProperty AccessKeyProperty { get; }
| }

+ public class Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs {
+   public AccessKeyDisplayDismissedEventArgs();
+ }

+ public class Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs {
+   public string PressedKeys { get; }
+   public AccessKeyDisplayRequestedEventArgs();
+ }

+ public class Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs {
+   public bool Handled { get; set; }
+   public AccessKeyInvokedEventArgs();
+ }

+ public class Windows.UI.Xaml.Input.AccessKeyManager {
+   public bool IsDisplayModeEnabled { get; }
+   public static void ExitDisplayMode();
+   TypedEventHandler<object, object> IsDisplayModeEnabledChanged;
+ }

+ public class Windows.UI.Xaml.Input.ContextRequestedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public bool Handled { get; set; }
+   public ContextRequestedEventArgs();
+   public bool TryGetPosition( UIElement returnValue, ref Point relativeTo );
+ }

| public enum Windows.UI.Xaml.Input.InputScopeNameValue {
+   ChatWithoutEmoji = 68,
| }

| public class Windows.UI.Xaml.Input.KeyRoutedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public string DeviceId { get; }
| }

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

+ public enum Windows.UI.Xaml.Media.FastPlayFallbackBehaviour {
+   Skip = 0,
+   Hide = 1,
+   Disable = 2,
+ }

+ public class Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs {
+   public void SetThumbnailImage( IInputStream source );
+   public Deferral GetDeferral();
+ }

+ public class Windows.UI.Xaml.Media.Animation.ConnectedAnimation {
+   public bool TryStart( UIElement returnValue );
+   public void Cancel();
+   TypedEventHandler<ConnectedAnimation, object> Completed;
+ }

+ public class Windows.UI.Xaml.Media.Animation.ConnectedAnimationService {
+   public CompositionEasingFunction DefaultEasingFunction { get; set; }
+   public TimeSpan DefaultDuration { get; set; }
+   public ConnectedAnimation PrepareToAnimate( string returnValue, UIElement key );
+   public ConnectedAnimation GetAnimation( string returnValue );
+   public static ConnectedAnimationService GetForCurrentView();
+ }

| public class Windows.UI.Xaml.Media.Animation.RepositionThemeTransition : Windows.UI.Xaml.Media.Animation.Transition {
+   public bool IsStaggeringEnabled { get; set; }
+   public DependencyProperty IsStaggeringEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Media.Imaging.BitmapImage : Windows.UI.Xaml.Media.Imaging.BitmapSource {
+   public bool AutoPlay { get; set; }
+   public bool IsAnimatedBitmap { get; }
+   public bool IsPlaying { get; }
+   public DependencyProperty AutoPlayProperty { get; }
+   public DependencyProperty IsAnimatedBitmapProperty { get; }
+   public DependencyProperty IsPlayingProperty { get; }
+   public void Play();
+   public void Stop();
| }

| public class Windows.UI.Xaml.Shapes.Shape : Windows.UI.Xaml.FrameworkElement {
+   public CompositionBrush GetAlphaMask();
| }

| public class Windows.Web.Http.Filters.HttpBaseProtocolFilter {
+   public void ClearAuthenticationCache();
| }

| public enum Windows.Web.Http.Filters.HttpCacheReadBehavior {
+   NoCache = 3,
| }

+ public class Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs {
+   public HttpRequestMessage RequestMessage { get; }
+   public Certificate ServerCertificate { get; }
+   public SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
+   public IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
+   public IVectorView<Certificate> ServerIntermediateCertificates { get; }
+   public void Reject();
+   public Deferral GetDeferral();
+ }