Windows Phone 10 9941 vs. 8.1 9651 WinRT API Changes

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

 new file: microsoft.mainos.production.spku_37d09bfbfe953b21f1e527f05e459153804a093b\1773_Windows.WinMD
 old file: WP81Emu\Windows.NI.WinMD

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

| public class Windows.ApplicationModel.Package {
+   public string Description { get; }
+   public string DisplayName { get; }
+   public bool IsBundle { get; }
+   public bool IsDevelopmentMode { get; }
+   public bool IsResourcePackage { get; }
+   public Uri Logo { get; }
+   public string PublisherDisplayName { get; }
+   public DateTime InstalledDate { get; }
+   public PackageStatus Status { get; }
| }

+ public class Windows.ApplicationModel.PackageStatus {
+   public bool DataOffline { get; }
+   public bool DependencyIssue { get; }
+   public bool DeploymentInProgress { get; }
+   public bool Disabled { get; }
+   public bool LicenseIssue { get; }
+   public bool Modified { get; }
+   public bool NeedsRemediation { get; }
+   public bool NotAvailable { get; }
+   public bool PackageOffline { get; }
+   public bool Servicing { get; }
+   public bool Tampered { get; }
+   public bool VerifyIsOK();
+ }

| public enum Windows.ApplicationModel.Activation.ActivationKind {
+   LockScreen = 17,
+   WebAccountProvider = 1006,
+   WebAccountProviderContinuation = 1007,
+   ComponentUI = 1008,
+   ProtocolWithResultsContinuation = 1009,
+   ProtocolForResults = 1010,
| }

+ public interface Windows.ApplicationModel.Activation.IFolderActivatedEventArgs {
+   public IStorageFolder Folder { get; }
+   public IVectorView<IStorageItem> SelectedItems { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.ILockScreenActivatedEventArgs {
+   public object Info { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData {
+   public string CallerPackageFamilyName { get; }
+   public ValueSet Data { get; }
+ }

* public interface Windows.ApplicationModel.Activation.ISplashScreen;

+ public interface Windows.ApplicationModel.Activation.IWebAccountProviderActivatedEventArgs {
+   public IWebAccountProviderOperation Operation { get; }
+ }

+ public interface Windows.ApplicationModel.Activation.IWebAccountProviderContinuationEventArgs {
+   public WebTokenRequestResult Result { get; }
+ }

+ public class Windows.ApplicationModel.Activation.LockScreenActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public object Info { get; }
+ }

| public class Windows.ApplicationModel.Activation.ProtocolActivatedEventArgs {
+   public string CallerPackageFamilyName { get; }
+   public ValueSet Data { get; }
| }

+ public class Windows.ApplicationModel.Activation.ProtocolForResultsActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public Uri Uri { get; }
+   public string CallerPackageFamilyName { get; }
+   public ValueSet Data { get; }
+   public ProtocolForResultsOperation ProtocolForResultsOperation { get; }
+ }

+ public class Windows.ApplicationModel.Activation.ProtocolWithResultsContinuationActivatedEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public ValueSet ContinuationData { get; }
+   public ValueSet Result { get; }
+ }

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

+ public class Windows.ApplicationModel.Activation.WebAccountProviderContinuationEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public WebTokenRequestResult Result { get; }
+ }

+ public class Windows.ApplicationModel.AppService.AppServiceClosedEventArgs {
+   public AppServiceClosedStatus Status { get; }
+ }

+ public enum Windows.ApplicationModel.AppService.AppServiceClosedStatus {
+   Completed = 0,
+   Canceled = 1,
+   ResourceLimitsExceeded = 2,
+   Unknown = 3,
+ }

+ public class Windows.ApplicationModel.AppService.AppServiceConnection {
+   public User User { get; set; }
+   public string PackageFamilyName { get; set; }
+   public string AppServiceName { get; set; }
+   public AppServiceConnection();
+   public IAsyncOperation<AppServiceConnectionStatus> OpenAsync();
+   public IAsyncOperation<AppServiceResponse> SendMessageAsync( ValueSet operation );
+   public void Close();
+   TypedEventHandler<AppServiceConnection, AppServiceRequestReceivedEventArgs> RequestReceived;
+   TypedEventHandler<AppServiceConnection, AppServiceClosedEventArgs> ServiceClosed;
+ }

+ public enum Windows.ApplicationModel.AppService.AppServiceConnectionStatus {
+   Success = 0,
+   AppNotInstalled = 1,
+   AppUnavailable = 2,
+   AppServiceUnavailable = 3,
+   Unknown = 4,
+ }

+ public class Windows.ApplicationModel.AppService.AppServiceDeferral {
+   public void Complete();
+ }

+ public class Windows.ApplicationModel.AppService.AppServiceRequest {
+   public ValueSet Message { get; }
+   public IAsyncOperation<AppServiceResponseStatus> SendResponseAsync( ValueSet operation );
+ }

+ public class Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs {
+   public AppServiceRequest Request { get; }
+   public AppServiceDeferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.AppService.AppServiceResponse {
+   public ValueSet Message { get; }
+   public AppServiceResponseStatus Status { get; }
+ }

+ public enum Windows.ApplicationModel.AppService.AppServiceResponseStatus {
+   Success = 0,
+   Failure = 1,
+   ResourceLimitsExceeded = 2,
+   Unknown = 3,
+ }

+ public class Windows.ApplicationModel.AppService.AppServiceTriggerDetails {
+   public AppServiceConnection AppServiceConnection { get; }
+   public string CallerPackageFamilyName { get; }
+   public string Name { get; }
+ }

| public class Windows.ApplicationModel.Appointments.Appointment {
+   public ulong ServerChangeNumber { get; set; }
+   public ulong ChangeNumber { get; }
| }

| public class Windows.ApplicationModel.Appointments.AppointmentCalendar {
+   public AppointmentCalendarSyncAdapter SyncAdapter { get; }
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncAdapter {
+   public AppointmentCalendarSyncState CurrentState { get; }
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+   public IAsyncOperation<bool> SyncAsync();
+   TypedEventHandler<AppointmentCalendar, AppointmentCalendarSyncStatusChangedEventArgs> SyncStatusChanged;
+ }

+ public enum Windows.ApplicationModel.Appointments.AppointmentCalendarSyncState {
+   Unknown = 0,
+   Idle = 1,
+   Syncing = 2,
+   Disconnected = 3,
+   Throttled = 4,
+   UserAttentionRequired = 5,
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentCalendarSyncStatusChangedEventArgs {
+   public AppointmentCalendarSyncState CurrentState { get; }
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+ }

| public class Windows.ApplicationModel.Appointments.AppointmentProperties {
+   public string ChangeNumber { get; }
+   public string ServerChangeNumber { get; }
| }

| public class Windows.ApplicationModel.Appointments.AppointmentStoreChange {
+   public AppointmentCalendar Calendar { get; }
| }

| public enum Windows.ApplicationModel.Appointments.AppointmentStoreChangeType {
+   CalendarCreated = 4,
+   CalendarModified = 5,
+   CalendarDeleted = 6,
| }

+ public class Windows.ApplicationModel.Appointments.AppointmentStoreChangedDeferral {
+   public void Complete();
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs {
+   public AppointmentStoreChangedDeferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Appointments.AppointmentStoreNotificationTriggerDetails {
+ }

+ public class Windows.ApplicationModel.Background.ActivitySensorTrigger {
+   public uint MinimumReportInterval { get; }
+   public uint ReportInterval { get; }
+   public IVector<ActivityType> SubscribedActivities { get; }
+   public IVectorView<ActivityType> SupportedActivities { get; }
+   public ActivitySensorTrigger( uint reportIntervalInMilliseconds );
+ }

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

+ public class Windows.ApplicationModel.Background.BluetoothLEAdvertisementPublisherTrigger {
+   public BluetoothLEAdvertisement Advertisement { get; }
+   public BluetoothLEAdvertisementPublisherTrigger();
+ }

+ public class Windows.ApplicationModel.Background.BluetoothLEAdvertisementWatcherTrigger {
+   public BluetoothSignalStrengthFilter SignalStrengthFilter { get; set; }
+   public BluetoothLEAdvertisementFilter AdvertisementFilter { get; set; }
+   public TimeSpan MaxOutOfRangeTimeout { get; }
+   public TimeSpan MaxSamplingInterval { get; }
+   public TimeSpan MinOutOfRangeTimeout { get; }
+   public TimeSpan MinSamplingInterval { get; }
+   public BluetoothLEAdvertisementWatcherTrigger();
+ }

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

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

+ public class Windows.ApplicationModel.Background.PhoneTrigger {
+   public bool OneShot { get; }
+   public PhoneTriggerType TriggerType { get; }
+   public PhoneTrigger( PhoneTriggerType type, bool oneShot );
+ }

+ public class Windows.ApplicationModel.Background.SensorDataThresholdTrigger {
+   public SensorDataThresholdTrigger( ISensorDataThreshold threshold );
+ }

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

+ public class Windows.ApplicationModel.Background.ToastNotificationHistoryChangedTrigger {
+   public ToastNotificationHistoryChangedTrigger( string applicationId );
+   public ToastNotificationHistoryChangedTrigger();
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneAudioRoutingEndpoint {
+   Default = 0,
+   Bluetooth = 1,
+   Speakerphone = 2,
+ }

| public class Windows.ApplicationModel.Calls.PhoneCallManager {
+   public bool IsCallActive { get; }
+   public bool IsCallIncoming { get; }
+   public static void ShowPhoneCallSettingsUI();
+   public static IAsyncOperation<PhoneCallStore> RequestStoreAsync();
| }

+ public enum Windows.ApplicationModel.Calls.PhoneCallMedia {
+   Audio = 0,
+   AudioAndVideo = 1,
+ }

+ public class Windows.ApplicationModel.Calls.PhoneCallStore {
+   public IAsyncOperation<bool> IsEmergencyPhoneNumberAsync( string result );
+   public IAsyncOperation<IObservableMap<Guid, PhoneLine>> GetPhoneLinesAsync();
+   public IAsyncAction SaveDefaultLineAsync( Guid result );
+   public IAsyncOperation<Guid> GetDefaultLineAsync();
+   public PhoneLineWatcher RequestLineWatcher();
+ }

+ public class Windows.ApplicationModel.Calls.PhoneDialOptions {
+   public string Number { get; set; }
+   public PhoneCallMedia Media { get; set; }
+   public string DisplayName { get; set; }
+   public ContactPhone ContactPhone { get; set; }
+   public Contact Contact { get; set; }
+   public PhoneAudioRoutingEndpoint AudioEndpoint { get; set; }
+   public PhoneDialOptions();
+ }

+ public class Windows.ApplicationModel.Calls.PhoneLine {
+   public bool CanDial { get; }
+   public PhoneLineCellularDetails CellularDetails { get; }
+   public Color DisplayColor { get; }
+   public string DisplayName { get; }
+   public Guid Id { get; }
+   public bool IsCallFilteringEnabled { get; }
+   public string NetworkName { get; }
+   public PhoneLineNetworkOperatorDisplayOptions NetworkOperatorDisplayOptions { get; }
+   public PhoneNetworkState NetworkState { get; }
+   public bool SupportsTile { get; }
+   public PhoneLineTransport Transport { get; }
+   public PhoneVoicemail Voicemail { get; }
+   public IAsyncOperation<bool> IsImmediateDialNumberAsync( string result );
+   public void Dial( string number, string displayName );
+   public void DialWithOptions( PhoneDialOptions options );
+   public static IAsyncOperation<PhoneLine> FromIdAsync( Guid result );
+   TypedEventHandler<PhoneLine, object> LineChanged;
+ }

+ public class Windows.ApplicationModel.Calls.PhoneLineCellularDetails {
+   public bool IsModemOn { get; }
+   public uint RegistrationRejectCode { get; }
+   public uint SimSlotIndex { get; }
+   public PhoneSimState SimState { get; }
+ }

+ public class Windows.ApplicationModel.Calls.PhoneLineNetworkOperatorDisplayOptions {
+   public bool ShouldDisplayEmergencyCallState { get; }
+   public bool ShouldDisplayExtendedRejectCodes { get; }
+   public bool ShouldDisplayNetworkStateInCallHistory { get; }
+   public bool ShouldDisplayNetworkStateInDialer { get; }
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneLineTransport {
+   Cellular = 0,
+   VoipApp = 1,
+ }

+ public class Windows.ApplicationModel.Calls.PhoneLineWatcher {
+   public PhoneLineWatcherStatus Status { get; }
+   public void Start();
+   public void Stop();
+   TypedEventHandler<PhoneLineWatcher, object> EnumerationCompleted;
+   TypedEventHandler<PhoneLineWatcher, PhoneLineWatcherEventArgs> LineAdded;
+   TypedEventHandler<PhoneLineWatcher, PhoneLineWatcherEventArgs> LineRemoved;
+   TypedEventHandler<PhoneLineWatcher, PhoneLineWatcherEventArgs> LineUpdated;
+   TypedEventHandler<PhoneLineWatcher, object> Stopped;
+ }

+ public class Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs {
+   public Guid LineId { get; }
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneLineWatcherStatus {
+   Created = 0,
+   Started = 1,
+   EnumerationCompleted = 2,
+   Stopped = 3,
+   Aborted = 4,
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneNetworkState {
+   Unknown = 0,
+   NoSignal = 1,
+   Deregistered = 2,
+   Denied = 3,
+   Searching = 4,
+   Home = 5,
+   RoamingInternational = 6,
+   RoamingDomestic = 7,
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneSimState {
+   Unknown = 0,
+   PinNotRequired = 1,
+   PinUnlocked = 2,
+   PinLocked = 3,
+   PukLocked = 4,
+   NotInserted = 5,
+   Invalid = 6,
+   Disabled = 7,
+ }

+ public class Windows.ApplicationModel.Calls.PhoneVoicemail {
+   public uint MessageCount { get; }
+   public string Number { get; }
+   public PhoneVoicemailType Type { get; }
+   public IAsyncAction DialVoicemailAsync();
+ }

+ public enum Windows.ApplicationModel.Calls.PhoneVoicemailType {
+   None = 0,
+   Traditional = 1,
+   Visual = 2,
+ }

+ public class Windows.ApplicationModel.Calls.Background.PhoneCallStateChangedTriggerDetails {
+   public uint ActiveCallCount { get; }
+   public uint EndedCallCount { get; }
+   public uint IncomingCallCount { get; }
+ }

+ public enum Windows.ApplicationModel.Calls.Background.PhoneLineChangeType {
+   Added = 0,
+   Removed = 1,
+   Changed = 2,
+ }

+ public class Windows.ApplicationModel.Calls.Background.PhoneLineChangedTriggerDetails {
+   public PhoneLineChangeType ChangeType { get; }
+   public Guid LineId { get; }
+   public bool HasLinePropertyChanged( PhoneLineProperties pResult );
+ }

+ public enum Windows.ApplicationModel.Calls.Background.PhoneLineProperties {
+   None = 0,
+   BrandingOptions = 1,
+   CanDial = 2,
+   CellularDetails = 4,
+   DisplayColor = 8,
+   Name = 16,
+   NetworkName = 32,
+   NetworkState = 64,
+   Transport = 128,
+   Voicemail = 256,
+ }

+ public enum Windows.ApplicationModel.Calls.Background.PhoneTriggerType {
+   CallStateChanged = 0,
+   NewVoicemailMessage = 1,
+   CallHistoryChanged = 2,
+   LineChanged = 3,
+   AirplaneModeDisabledForEmergencyCall = 4,
+ }

+ public class Windows.ApplicationModel.Calls.Background.PhoneVoicemailCountChangedTriggerDetails {
+   public Guid LineId { get; }
+   public uint VoicemailCount { get; }
+   public string VoicemailMessage { get; }
+ }

+ public class Windows.ApplicationModel.Chat.ChatConversation {
+   public bool IsConversationMuted { get; set; }
+   public bool HasUnreadMessages { get; }
+   public string Id { get; }
+   public string MostRecentMessageId { get; }
+   public IVector<string> Participants { get; }
+   public ChatConversationThreadingInfo ThreadingInfo { get; }
+   public IAsyncAction DeleteAsync();
+   public ChatMessageReader GetMessageReader();
+   public IAsyncAction MarkAsReadAsync();
+   public IAsyncAction SaveAsync();
+ }

+ public class Windows.ApplicationModel.Chat.ChatConversationReader {
+   public IAsyncOperation<IVectorView<ChatConversation>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.Chat.ChatConversationThreadingInfo {
+   public ChatConversationThreadingType Type { get; set; }
+   public string Custom { get; set; }
+   public string ConversationId { get; set; }
+   public string ContactId { get; set; }
+   public IVector<string> Participants { get; }
+   public ChatConversationThreadingInfo();
+ }

+ public enum Windows.ApplicationModel.Chat.ChatConversationThreadingType {
+   Participants = 0,
+   Contact = 1,
+   ConversationId = 2,
+   Custom = 3,
+ }

| public class Windows.ApplicationModel.Chat.ChatMessage {
*   public bool IsRead { get; set; }
*   public bool IsIncoming { get; set; }
*   public bool IsForwardingDisabled { get; set; }
*   public string From { get; set; }
*   public DateTime LocalTimestamp { get; set; }
*   public DateTime NetworkTimestamp { get; set; }
*   public ChatMessageStatus Status { get; set; }
+   public ulong DownloadSize { get; set; }
+   public ChatConversationThreadingInfo ThreadingInfo { get; set; }
+   public bool SupressNotification { get; set; }
+   public string RemoteId { get; set; }
+   public ChatMessageType MessageType { get; set; }
+   public bool IsDraft { get; set; }
+   public IVector<ChatRecipient> RecipientsInfo { get; }
+   public bool IsSIMMessage { get; }
| }

| public class Windows.ApplicationModel.Chat.ChatMessageManager {
+   public static string TryRegisterAsTransportAsync();
| }

+ public enum Windows.ApplicationModel.Chat.ChatMessageNotificationAction {
+   None = 0,
+   Poke = 1,
+   Toast = 2,
+   Tile = 4,
+   Badge = 8,
+   ActionCenter = 16,
+ }

+ public enum Windows.ApplicationModel.Chat.ChatMessageNotificationPretreatment {
+   AutoReplied = 1,
+   PlayedOverSpeech = 2,
+ }

| public class Windows.ApplicationModel.Chat.ChatMessageNotificationTriggerDetails {
+   public ChatMessageNotificationAction Actions { get; }
+   public ChatMessageNotificationPretreatment Pretreatments { get; }
| }

| public class Windows.ApplicationModel.Chat.ChatMessageStore {
+   public IAsyncOperation<ChatConversation> GetConversationAsync( string value );
+   public IAsyncOperation<ChatConversation> GetConversationAsync( string value, IVectorView<string> id );
+   public ChatConversationReader GetConversationReader();
+   public ChatConversationReader GetConversationReader( IVectorView<string> value );
+   public IAsyncOperation<ChatMessage> GetMessageByRemoteIdAsync( string value, string transportId );
+   public IAsyncOperation<uint> GetUnseenCountAsync();
+   public IAsyncOperation<uint> GetUnseenCountAsync( IVectorView<string> value );
+   public IAsyncAction MarkAsSeenAsync();
+   public IAsyncAction MarkAsSeenAsync( IVectorView<string> value );
+   public IAsyncAction SaveMessageAsync( ChatMessage value );
| }

| public class Windows.ApplicationModel.Chat.ChatMessageTransport {
+   public ChatMessageTransportSettings Settings { get; }
| }

+ public class Windows.ApplicationModel.Chat.ChatMessageTransportSettings {
+   public uint AttachmentLimit { get; }
+   public uint MaxSize { get; }
+   public uint RecipientLimit { get; }
+   public ChatMessageVideoFormat VideoFormat { get; }
+ }

+ public enum Windows.ApplicationModel.Chat.ChatMessageType {
+   Standard = 0,
+   AutoReply = 1,
+   ReceivedDuringQuiteHours = 2,
+   FileTransferRequest = 3,
+   TransportCustom = 4,
+ }

+ public enum Windows.ApplicationModel.Chat.ChatMessageVideoFormat {
+   H264_AAC_MP4 = 0,
+   H254_AAC_3GP = 1,
+   H263_AMRNB_3GP = 2,
+   MPEG4_AMRNB_3GP = 3,
+ }

+ public class Windows.ApplicationModel.Chat.ChatRecipient {
+   public ChatRecipientStatus Status { get; set; }
+   public IReference<DateTime> ReadTime { get; set; }
+   public IReference<DateTime> DeliveryTime { get; set; }
+   public string Address { get; set; }
+   public ChatRecipient();
+ }

+ public class Windows.ApplicationModel.Chat.ChatRecipientStatus {
+   public IReference<uint> Result { get; set; }
+   public bool HasPermanentError { get; set; }
+   public IReference<uint> ErrorCode2 { get; set; }
+   public IReference<uint> ErrorCode1 { get; set; }
+   public ChatRecipientStatus();
+ }

+ public class Windows.ApplicationModel.Chat.ChatStoreChangedEventArgs {
+   public string Id { get; }
+   public ChatStoreChangedEventType Type { get; }
+ }

+ public enum Windows.ApplicationModel.Chat.ChatStoreChangedEventType {
+   Lost = 0,
+   StoreModified = 1,
+   MessageCreated = 2,
+   MessageModified = 3,
+   MessageDeleted = 4,
+   ConversationModified = 5,
+   ConversationDeleted = 6,
+   ConversationTransportDeleted = 7,
+ }

| public class Windows.ApplicationModel.Contacts.ContactStore {
+   public IAsyncOperation<IVectorView<Contact>> FindContactsAsync( string contacts );
+   public IAsyncOperation<Contact> GetContactAsync( string contacts );
| }

+ public class Windows.ApplicationModel.ContactsTemp.AggregateContactManager {
+   public IAsyncOperation<IVectorView<Contact>> FindRawContactsAsync( Contact value );
+   public IAsyncOperation<Contact> TryLinkContactsAsync( Contact contact, Contact primaryContact );
+   public IAsyncAction UnlinkRawContactAsync( Contact value );
+   public IAsyncAction SaveAggregateContactAsync( Contact value );
+ }

+ public class Windows.ApplicationModel.ContactsTemp.Contact {
+   public IRandomAccessStreamReference Thumbnail { get; set; }
+   public string Name { get; set; }
+   public IVector<IContactField> Fields { get; }
+   public string Notes { get; set; }
+   public string Id { get; set; }
+   public IVector<ContactConnectedServiceAccount> ConnectedServiceAccounts { get; }
+   public IVector<string> DataSuppliers { get; }
+   public IVector<ContactEmail> Emails { get; }
+   public IVector<ContactDate> ImportantDates { get; }
+   public IVector<ContactJobInfo> JobInfo { get; }
+   public IVector<ContactAddress> Addresses { get; }
+   public IVector<ContactPhone> Phones { get; }
+   public IPropertySet ProviderProperties { get; }
+   public IVector<ContactSignificantOther> SignificantOthers { get; }
+   public IVector<ContactWebsite> Websites { get; }
+   public string RemoteId { get; set; }
+   public IRandomAccessStreamReference RingTone { get; set; }
+   public IRandomAccessStreamReference SourceDisplayPicture { get; set; }
+   public IRandomAccessStreamReference TextTone { get; set; }
+   public DateTime DisplayPictureUserUpdateTime { get; set; }
+   public string ManualDisplayName { get; set; }
+   public string Nickname { get; set; }
+   public bool IsMe { get; }
+   public IRandomAccessStreamReference LargeDisplayPicture { get; }
+   public IRandomAccessStreamReference SmallDisplayPicture { get; }
+   public bool IsDisplayPictureManuallySet { get; }
+   public string AggregateId { get; }
+   public string ContactListId { get; }
+   public string FullName { get; }
+   public bool IsAggregate { get; }
+   public string HonorificNameSuffix { get; set; }
+   public string YomiGivenName { get; set; }
+   public string MiddleName { get; set; }
+   public string LastName { get; set; }
+   public string YomiFamilyName { get; set; }
+   public string HonorificNamePrefix { get; set; }
+   public string FirstName { get; set; }
+   public string DisplayName { get; }
+   public string YomiDisplayName { get; }
+   public Contact();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactAddress {
+   public string StreetAddress { get; set; }
+   public string Region { get; set; }
+   public string PostalCode { get; set; }
+   public string Locality { get; set; }
+   public ContactAddressKind Kind { get; set; }
+   public string Description { get; set; }
+   public string Country { get; set; }
+   public ContactAddress();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactAddressKind {
+   Home = 0,
+   Work = 1,
+   Other = 2,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactBatch {
+   public IVectorView<Contact> Contacts { get; }
+   public ContactBatchStatus Status { get; }
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactBatchStatus {
+   Success = 0,
+   ServerSearchPartnershipError = 1,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactCardDelayedDataLoader {
+   public void SetData( Contact contact );
+   public void Close();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactChange {
+   public ContactChangeType ChangeType { get; }
+   public Contact Contact { get; }
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactChangeReader {
+   public void AcceptChanges();
+   public void AcceptChangesThrough( ContactChange lastChangeToAccept );
+   public IAsyncOperation<IVectorView<ContactChange>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactChangeTracker {
+   public void Enable();
+   public ContactChangeReader GetChangeReader();
+   public void Reset();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactChangeType {
+   Created = 0,
+   Modified = 1,
+   Deleted = 2,
+   ChangeTrackingLost = 3,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactChangedDeferral {
+   public void Complete();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactChangedEventArgs {
+   public ContactChangedDeferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactConnectedServiceAccount {
+   public string ServiceName { get; set; }
+   public string Id { get; set; }
+   public ContactConnectedServiceAccount();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactDate {
+   public IReference<int> Year { get; set; }
+   public IReference<uint> Month { get; set; }
+   public ContactDateKind Kind { get; set; }
+   public string Description { get; set; }
+   public IReference<uint> Day { get; set; }
+   public ContactDate();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactDateKind {
+   Birthday = 0,
+   Anniversary = 1,
+   Other = 2,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactEmail {
+   public ContactEmailKind Kind { get; set; }
+   public string Description { get; set; }
+   public string Address { get; set; }
+   public ContactEmail();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactEmailKind {
+   Personal = 0,
+   Work = 1,
+   Other = 2,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactField {
+   public ContactFieldCategory Category { get; }
+   public string Name { get; }
+   public ContactFieldType Type { get; }
+   public string Value { get; }
+   public ContactField( string value, ContactFieldType type );
+   public ContactField( string value, ContactFieldType type, ContactFieldCategory category );
+   public ContactField( string name, string value, ContactFieldType type, ContactFieldCategory category );
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactFieldCategory {
+   None = 0,
+   Home = 1,
+   Work = 2,
+   Mobile = 3,
+   Other = 4,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactFieldFactory {
+   public ContactFieldFactory();
+   public ContactField CreateField( string field, ContactFieldType value );
+   public ContactField CreateField( string field, ContactFieldType value, ContactFieldCategory type );
+   public ContactField CreateField( string field, string name, ContactFieldType value, ContactFieldCategory type );
+   public ContactLocationField CreateLocation( string field );
+   public ContactLocationField CreateLocation( string field, ContactFieldCategory unstructuredAddress );
+   public ContactLocationField CreateLocation( string field, ContactFieldCategory unstructuredAddress, string category, string street, string city, string region, string country );
+   public ContactInstantMessageField CreateInstantMessage( string field );
+   public ContactInstantMessageField CreateInstantMessage( string field, ContactFieldCategory userName );
+   public ContactInstantMessageField CreateInstantMessage( string field, ContactFieldCategory userName, string category, string service, Uri displayText );
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactFieldType {
+   Email = 0,
+   PhoneNumber = 1,
+   Address = 7,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactGroup {
+   public ContactGroupKind Kind { get; set; }
+   public string DisplayName { get; set; }
+   public string Id { get; }
+   public IVector<string> MemberIds { get; }
+   public ContactGroup();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactGroupChange {
+   public ContactGroupChangeType ChangeType { get; }
+   public ContactGroup ContactGroup { get; }
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactGroupChangeReader {
+   public void AcceptChanges();
+   public void AcceptChangesThrough( ContactGroupChange lastChangeToAccept );
+   public IAsyncOperation<IVectorView<ContactGroupChange>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactGroupChangeTracker {
+   public void Enable();
+   public ContactGroupChangeReader GetChangeReader();
+   public void Reset();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactGroupChangeType {
+   ContactGroupCreated = 0,
+   ContactGroupModified = 1,
+   ContactGroupDeleted = 2,
+   ChangeTrackingLost = 3,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactGroupChangedDeferral {
+   public void Complete();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactGroupChangedEventArgs {
+   public ContactGroupChangedDeferral GetDeferral();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactGroupKind {
+   Default = 0,
+   Room = 1,
+   SpeedDial = 2,
+   Custom = 65535,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactInformation {
+   public IVectorView<ContactField> CustomFields { get; }
+   public IVectorView<ContactField> Emails { get; }
+   public IVectorView<ContactInstantMessageField> InstantMessages { get; }
+   public IVectorView<ContactLocationField> Locations { get; }
+   public string Name { get; }
+   public IVectorView<ContactField> PhoneNumbers { get; }
+   public IAsyncOperation<IRandomAccessStreamWithContentType> GetThumbnailAsync();
+   public IVectorView<ContactField> QueryCustomFields( string value );
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactInstantMessageField {
+   public ContactFieldCategory Category { get; }
+   public string Name { get; }
+   public ContactFieldType Type { get; }
+   public string Value { get; }
+   public string DisplayText { get; }
+   public Uri LaunchUri { get; }
+   public string Service { get; }
+   public string UserName { get; }
+   public ContactInstantMessageField( string userName );
+   public ContactInstantMessageField( string userName, ContactFieldCategory category );
+   public ContactInstantMessageField( string userName, ContactFieldCategory category, string service, string displayText, Uri verb );
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactJobInfo {
+   public string Title { get; set; }
+   public string Office { get; set; }
+   public string Manager { get; set; }
+   public string Description { get; set; }
+   public string Department { get; set; }
+   public string CompanyYomiName { get; set; }
+   public string CompanyName { get; set; }
+   public string CompanyAddress { get; set; }
+   public ContactJobInfo();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactList {
+   public ContactListOtherAppWriteAccess OtherAppWriteAccess { get; set; }
+   public ContactListOtherAppReadAccess OtherAppReadAccess { get; set; }
+   public bool IsHidden { get; set; }
+   public string DisplayName { get; set; }
+   public ContactPropertiesConstraints Constraints { get; set; }
+   public ContactChangeTracker ChangeTracker { get; }
+   public string Id { get; }
+   public string SourceDisplayName { get; }
+   public bool SupportsServerSearch { get; }
+   public ContactListSyncAdapter SyncAdapter { get; }
+   public IAsyncAction SaveAsync();
+   public IAsyncAction DeleteAsync();
+   public IAsyncOperation<Contact> GetContactFromRemoteIdAsync( string contact );
+   public IAsyncOperation<Contact> GetMeContactAsync();
+   public ContactReader GetContactReader();
+   public ContactReader GetContactReader( ContactQuery value );
+   public IAsyncAction SaveContactAsync( Contact value );
+   public IAsyncAction DeleteContactAsync( Contact value );
+   public IAsyncOperation<Contact> GetContactAsync( string contacts );
+   TypedEventHandler<ContactList, ContactChangedEventArgs> ContactChanged;
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactListOtherAppReadAccess {
+   SystemOnly = 0,
+   Limited = 1,
+   Full = 2,
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactListOtherAppWriteAccess {
+   None = 0,
+   SystemOnly = 1,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactListSyncAdapter {
+   public ContactListSyncState CurrentState { get; }
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+   public IAsyncOperation<bool> SyncAsync();
+   TypedEventHandler<ContactList, ContactListSyncStatusChangedEventArgs> SyncStatusChanged;
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactListSyncState {
+   Unknown = 0,
+   Idle = 1,
+   Syncing = 2,
+   Disconnected = 3,
+   Throttled = 4,
+   UserAttentionRequired = 5,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactListSyncStatusChangedEventArgs {
+   public ContactListSyncState CurrentState { get; }
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactLocationField {
+   public ContactFieldCategory Category { get; }
+   public string Name { get; }
+   public ContactFieldType Type { get; }
+   public string Value { get; }
+   public string City { get; }
+   public string Country { get; }
+   public string PostalCode { get; }
+   public string Region { get; }
+   public string Street { get; }
+   public string UnstructuredAddress { get; }
+   public ContactLocationField( string unstructuredAddress );
+   public ContactLocationField( string unstructuredAddress, ContactFieldCategory category );
+   public ContactLocationField( string unstructuredAddress, ContactFieldCategory category, string street, string city, string region, string country, string postalCode );
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactManager {
+   public static IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact vCard );
+   public static IAsyncOperation<RandomAccessStreamReference> ConvertContactToVCardAsync( Contact vCard, uint contact );
+   public static IAsyncOperation<Contact> ConvertVCardToContactAsync( RandomAccessStreamReference contact );
+   public static IAsyncOperation<ContactStore> RequestStoreAsync( ContactStoreAccessType store );
+   public static IAsyncOperation<ContactStore> RequestStoreAsync();
+   public static void ShowContactCard( Contact contact, Rect selection );
+   public static void ShowContactCard( Contact contact, Rect selection, Placement preferredPlacement );
+   public static ContactCardDelayedDataLoader ShowDelayLoadedContactCard( Contact dataLoader, Rect contact, Placement selection );
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactMatchReason {
+   public ContactMatchReasonType MatchedField { get; }
+   public IVectorView<TextSegment> MatchedSegments { get; }
+   public string MatchedText { get; }
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactMatchReasonType {
+   ContactName = 0,
+   ContactEmail = 1,
+   ContactPhone = 2,
+   ContactJobInfo = 3,
+   ContactYomiName = 4,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactPhone {
+   public string Number { get; set; }
+   public ContactPhoneKind Kind { get; set; }
+   public string Description { get; set; }
+   public ContactPhone();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactPhoneKind {
+   Home = 0,
+   Mobile = 1,
+   Work = 2,
+   Other = 3,
+   Pager = 4,
+   BusinessFax = 5,
+   HomeFax = 6,
+   Company = 7,
+   Assistant = 8,
+   Radio = 9,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactPropertiesConstraints {
+   public IReference<int> MaxOtherEmailCount { get; set; }
+   public IReference<int> MaxOtherAddressCount { get; set; }
+   public IReference<int> MaxMobilePhoneCount { get; set; }
+   public IReference<int> MaxHomePhoneCount { get; set; }
+   public IReference<int> MaxHomeFaxPhoneCount { get; set; }
+   public IReference<int> MaxHomeEmailCount { get; set; }
+   public IReference<int> MaxWorkPhoneCount { get; set; }
+   public IReference<int> MaxCompanyPhoneCount { get; set; }
+   public IReference<int> MaxChildCountCount { get; set; }
+   public IReference<int> MaxPagerPhoneCount { get; set; }
+   public bool UseFirstNameOnly { get; set; }
+   public bool NoPropertyDescriptions { get; set; }
+   public IReference<int> MaxHomeAddressCount { get; set; }
+   public IReference<int> MaxWorkFaxPhoneCount { get; set; }
+   public IReference<int> MaxWorkEmailCount { get; set; }
+   public IReference<int> MaxWorkAddressCount { get; set; }
+   public IReference<int> MaxWebsiteCount { get; set; }
+   public IReference<int> MaxSiblingCountCount { get; set; }
+   public IReference<int> MaxParentCount { get; set; }
+   public ContactPropertiesConstraints();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactQuery {
+   public string SearchText { get; set; }
+   public ContactQuerySearchFields SearchFields { get; set; }
+   public ContactQueryRequiredFields RequiredFields { get; set; }
+   public bool OnlyServerSearchResults { get; set; }
+   public bool IncludeContactsFromHiddenLists { get; set; }
+   public IVector<string> ContactListIds { get; }
+   public ContactQuery();
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactQueryRequiredFields {
+   None = 0,
+   PhoneNumber = 1,
+   EmailAddress = 2,
+   PostalAddress = 4,
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactQuerySearchFields {
+   None = 0,
+   Name = 1,
+   Email = 2,
+   Phone = 4,
+   All = 4294967295,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactReader {
+   public IAsyncOperation<ContactBatch> ReadBatchAsync();
+   public IVectorView<ContactMatchReason> GetMatchingPropertiesWithMatchReason( Contact ppRetVal );
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactRelationship {
+   Other = 0,
+   Spouse = 1,
+   Partner = 2,
+   Sibling = 3,
+   Parent = 4,
+   Child = 5,
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactSelectionMode {
+   Contacts = 0,
+   Fields = 1,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactSignificantOther {
+   public string Name { get; set; }
+   public string Description { get; set; }
+   public ContactRelationship Relationship { get; set; }
+   public ContactSignificantOther();
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactStore {
+   public AggregateContactManager AggregateContactManager { get; }
+   public ContactChangeTracker ChangeTracker { get; }
+   public ContactGroupChangeTracker GroupChangeTracker { get; }
+   public IAsyncOperation<IVectorView<Contact>> FindContactsAsync();
+   public IAsyncOperation<IVectorView<Contact>> FindContactsAsync( string contacts );
+   public IAsyncOperation<Contact> GetContactAsync( string contacts );
+   public IAsyncOperation<IVectorView<ContactList>> FindContactListsAsync();
+   public IAsyncOperation<ContactList> GetContactListAsync( string value );
+   public IAsyncOperation<ContactList> CreateContactListAsync( string value );
+   public IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
+   public IAsyncOperation<ContactGroup> GetContactGroupAsync( string value );
+   public IAsyncAction SaveContactGroupAsync( ContactGroup value );
+   public IAsyncAction DeleteContactGroupAsync( ContactGroup value );
+   public IAsyncOperation<Contact> GetMeContactAsync();
+   public ContactReader GetContactReader();
+   public ContactReader GetContactReader( ContactQuery value );
+   TypedEventHandler<ContactStore, ContactChangedEventArgs> ContactChanged;
+   TypedEventHandler<ContactStore, ContactGroupChangedEventArgs> ContactGroupChanged;
+ }

+ public enum Windows.ApplicationModel.ContactsTemp.ContactStoreAccessType {
+   AppContactsReadWrite = 0,
+   AllContactsReadOnly = 1,
+   AllContactsReadWrite = 2,
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactStoreNotificationTriggerDetails {
+ }

+ public class Windows.ApplicationModel.ContactsTemp.ContactWebsite {
+   public Uri Uri { get; set; }
+   public string Description { get; set; }
+   public string RawUri { get; set; }
+   public ContactWebsite();
+ }

+ public interface Windows.ApplicationModel.ContactsTemp.IContactField {
+   public ContactFieldCategory Category { get; }
+   public string Name { get; }
+   public ContactFieldType Type { get; }
+   public string Value { get; }
+ }

+ public interface Windows.ApplicationModel.ContactsTemp.IContactFieldFactory {
+   public ContactField CreateField( string field, ContactFieldType value );
+   public ContactField CreateField( string field, ContactFieldType value, ContactFieldCategory type );
+   public ContactField CreateField( string field, string name, ContactFieldType value, ContactFieldCategory type );
+ }

+ public interface Windows.ApplicationModel.ContactsTemp.IContactInstantMessageFieldFactory {
+   public ContactInstantMessageField CreateInstantMessage( string field );
+   public ContactInstantMessageField CreateInstantMessage( string field, ContactFieldCategory userName );
+   public ContactInstantMessageField CreateInstantMessage( string field, ContactFieldCategory userName, string category, string service, Uri displayText );
+ }

+ public interface Windows.ApplicationModel.ContactsTemp.IContactLocationFieldFactory {
+   public ContactLocationField CreateLocation( string field );
+   public ContactLocationField CreateLocation( string field, ContactFieldCategory unstructuredAddress );
+   public ContactLocationField CreateLocation( string field, ContactFieldCategory unstructuredAddress, string category, string street, string city, string region, string country );
+ }

+ public class Windows.ApplicationModel.DataTransfer.Clipboard {
+   public static DataPackageView GetContent();
+   public static void SetContent( DataPackage content );
+   public static void Flush();
+   public static void Clear();
+   EventHandler<object> ContentChanged;
+ }

+ public class Windows.ApplicationModel.DataTransfer.SharedStorageAccessManager {
+   public static string AddFile( IStorageFile outToken );
+   public static IAsyncOperation<StorageFile> RedeemTokenForFileAsync( string operation );
+   public static void RemoveFile( string token );
+ }

| public class Windows.ApplicationModel.Email.EmailAttachment {
+   public ulong Size { get; set; }
+   public string MimeType { get; set; }
+   public bool IsInline { get; set; }
+   public EmailAttachmentDownloadState DownloadState { get; set; }
+   public string ContentLocation { get; set; }
+   public string ContentId { get; set; }
+   public string Id { get; }
+   public EmailAttachment( string fileName, IRandomAccessStreamReference data, string mimeType );
| }

+ public enum Windows.ApplicationModel.Email.EmailAttachmentDownloadState {
+   NotDownloaded = 0,
+   Downloading = 1,
+   Downloaded = 2,
+   Failed = 3,
+ }

+ public enum Windows.ApplicationModel.Email.EmailBatchStatus {
+   Success = 0,
+   ServerSearchPartnershipError = 1,
+   ServerSearchUnknownError = 2,
+ }

+ public enum Windows.ApplicationModel.Email.EmailClassification {
+   NormalMessage = 0,
+   Newsletter = 1,
+ }

+ public class Windows.ApplicationModel.Email.EmailConversation {
+   public EmailFlagState FlagState { get; }
+   public bool HasAttachment { get; }
+   public string Id { get; }
+   public EmailImportance Importance { get; }
+   public EmailMessageResponseType LastEmailResponseType { get; }
+   public EmailRecipient LatestSender { get; }
+   public string MailboxId { get; }
+   public uint MessageCount { get; }
+   public string MostRecentMessageId { get; }
+   public DateTime MostRecentMessageTime { get; }
+   public string Preview { get; }
+   public string Subject { get; }
+   public uint UnreadMessageCount { get; }
+   public IAsyncOperation<IVectorView<EmailMessage>> FindMessagesAsync();
+   public IAsyncOperation<IVectorView<EmailMessage>> FindMessagesAsync( uint result );
+ }

+ public class Windows.ApplicationModel.Email.EmailConversationBatch {
+   public IVectorView<EmailConversation> Conversations { get; }
+   public EmailBatchStatus Status { get; }
+ }

+ public class Windows.ApplicationModel.Email.EmailConversationReader {
+   public IAsyncOperation<EmailConversationBatch> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.Email.EmailFetchOptions {
+   public EmailSortProperty SortProperty { get; set; }
+   public EmailSortDirection SortDirection { get; set; }
+   public string SearchString { get; set; }
+   public EmailSearchFields SearchFields { get; set; }
+   public bool OnlyServerSearchResults { get; set; }
+   public EmailMessageTypeFilter MessageTypeFilter { get; set; }
+   public IVector<string> FolderIds { get; }
+   public EmailFetchOptions();
+ }

+ public enum Windows.ApplicationModel.Email.EmailFlagState {
+   Unflagged = 0,
+   Flagged = 1,
+   Completed = 2,
+   Cleared = 3,
+ }

+ public class Windows.ApplicationModel.Email.EmailFolder {
+   public string RemoteId { get; set; }
+   public DateTime LastSync { get; set; }
+   public bool IsSyncing { get; set; }
+   public string DisplayName { get; set; }
+   public string Id { get; }
+   public string MailboxId { get; }
+   public string ParentFolderId { get; }
+   public EmailSpecialFolderType SpecialFolderType { get; }
+   public IAsyncOperation<IVectorView<EmailFolder>> FindChildFoldersAsync();
+   public EmailConversationReader GetConversationReader();
+   public EmailConversationReader GetConversationReader( EmailFetchOptions result );
+   public EmailMessageReader GetMessageReader();
+   public EmailMessageReader GetMessageReader( EmailFetchOptions result );
+   public IAsyncOperation<EmailItemCounts> GetMessageCountsAsync();
+   public IAsyncOperation<bool> TryMoveAsync( EmailFolder result );
+   public IAsyncOperation<bool> TryMoveAsync( EmailFolder result, string newParentFolder );
+   public IAsyncAction DeleteAsync();
+   public IAsyncOperation<bool> TrySaveAsync();
+   public IAsyncOperation<EmailFolder> CreateFolderAsync( string result );
+   public IAsyncOperation<EmailMessage> GetMessageAsync( string result );
+   public IAsyncAction SaveMessageAsync( EmailMessage result );
+ }

+ public enum Windows.ApplicationModel.Email.EmailImportance {
+   Normal = 0,
+   High = 1,
+   Low = 2,
+ }

+ public enum Windows.ApplicationModel.Email.EmailIrmPermissions {
+   EditAllowed = 1,
+   ReplyAllowed = 2,
+   ReplyAllAllowed = 4,
+   ForwardAllowed = 8,
+   ModifyRecipientsAllowed = 16,
+   ExtractAllowed = 32,
+   PrintAllowed = 64,
+   ExportAllowed = 128,
+   ProgrammaticAccessAllowed = 256,
+   Owner = 512,
+   AllPermissions = 4294967295,
+ }

+ public class Windows.ApplicationModel.Email.EmailIrmTemplate {
+   public string Name { get; set; }
+   public string Id { get; set; }
+   public string Description { get; set; }
+   public EmailIrmTemplate( string id, string name, string description );
+   public EmailIrmTemplate();
+ }

+ public struct Windows.ApplicationModel.Email.EmailItemCounts {
+   public uint Total;
+   public uint Unread;
+   public uint Flagged;
+   public uint Urgent;
+ }

+ public class Windows.ApplicationModel.Email.EmailMailbox {
+   public EmailMailboxOtherAppWriteAccess OtherAppWriteAccess { get; set; }
+   public EmailMailboxOtherAppReadAccess OtherAppReadAccess { get; set; }
+   public string DisplayName { get; set; }
+   public string MailAddress { get; set; }
+   public EmailMailboxCapabilities Capabilities { get; }
+   public EmailMailboxChangeTracker ChangeTracker { get; }
+   public string Id { get; }
+   public bool IsAppOwnedMailbox { get; }
+   public EmailMailboxType MailboxType { get; }
+   public bool MustEncryptSmimeMessages { get; }
+   public bool MustEncryptUnderLockscreen { get; }
+   public bool MustSignSmimeMessages { get; }
+   public bool AllowSmimeEncryptionAlgorithmNegotiation { get; }
+   public bool AllowSmimeSoftCerts { get; }
+   public SmimeEncryptionAlgorithm RequiredSmimeEncryptionAlgorithm { get; }
+   public SmimeSigningAlgorithm RequiredSmimeSigningAlgorithm { get; }
+   public string SourceDisplayName { get; }
+   public EmailMailboxSyncAdapter SyncAdapter { get; }
+   public EmailConversationReader GetConversationReader();
+   public EmailConversationReader GetConversationReader( EmailFetchOptions result );
+   public EmailMessageReader GetMessageReader();
+   public EmailMessageReader GetMessageReader( EmailFetchOptions result );
+   public IAsyncOperation<IVectorView<EmailIrmTemplate>> GetSupportedIrmTemplatesAsync();
+   public IAsyncAction DeleteAsync();
+   public IAsyncOperation<EmailConversation> GetConversationAsync( string result );
+   public IAsyncOperation<EmailFolder> GetFolderAsync( string result );
+   public IAsyncOperation<EmailMessage> GetMessageAsync( string result );
+   public IAsyncOperation<EmailFolder> GetSpecialFolderAsync( EmailSpecialFolderType result );
+   public IAsyncAction SaveAsync();
+   public IAsyncAction MarkMessageAsSeenAsync( string result );
+   public IAsyncAction MarkFolderAsSeenAsync( string result );
+   public IAsyncAction MarkMessageReadAsync( string result, bool messageId );
+   public IAsyncAction ChangeMessageFlagStateAsync( string result, EmailFlagState messageId );
+   public IAsyncOperation<bool> TryMoveMessageAsync( string result, string messageId );
+   public IAsyncOperation<bool> TryMoveFolderAsync( string result, string folderId );
+   public IAsyncOperation<bool> TryMoveFolderAsync( string result, string folderId, string newParentFolderId );
+   public IAsyncAction DeleteMessageAsync( string result );
+   public IAsyncAction MarkFolderSyncingAsync( string result, bool folderId );
+   public IAsyncAction SendMessageAsync( EmailMessage result );
+   public IAsyncAction SaveDraftAsync( EmailMessage result );
+   public IAsyncAction DownloadMessageAsync( string result );
+   public IAsyncAction DownloadAttachmentAsync( string result );
+   public IAsyncOperation<EmailMessage> CreateResponseMessageAsync( string result, EmailMessageResponseType messageId, string responseType, EmailMessageBodyType subject, string responseHeaderType );
+   public IAsyncAction RespondToMeetingAsync( EmailMessage result, EmailMeetingResponseType meeting, string response, string subject, bool comment );
+   public IAsyncAction RespondToMeetingAppointmentAsync( Appointment result, EmailMeetingResponseType meeting, string response, string subject, bool comment );
+   public IAsyncAction ForwardMeetingAsync( EmailMessage result, IVector<EmailRecipient> meeting, string recipients, EmailMessageBodyType subject, string forwardHeaderType, string forwardHeader );
+   public IAsyncAction ForwardMeetingAppointmentAsync( Appointment result, IVector<EmailRecipient> meeting, string recipients, EmailMessageBodyType subject, string forwardHeaderType, string forwardHeader );
+   public IAsyncAction ProposeNewTimeForMeetingAsync( EmailMessage result, DateTime meeting, TimeSpan newStartTime, string newDuration, string subject );
+   public IAsyncAction ProposeNewTimeForMeetingAppointmentAsync( Appointment result, DateTime meeting, TimeSpan newStartTime, string newDuration, string subject );
+   public IAsyncAction CreateMeetingAsync( AppointmentCalendar result, Appointment calendar );
+   public IAsyncAction UpdateMeetingAsync( Appointment result );
+   public IAsyncOperation<EmailMailboxSyncStatus> SyncAsync();
+   TypedEventHandler<EmailMailbox, EmailMailboxChangedEventArgs> MailboxChanged;
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxAction {
+   public EmailMailboxActionType ActionType { get; }
+   public ulong ChangeNumber { get; }
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxActionType {
+   MarkMessageAsSeen = 0,
+   MarkMessageRead = 1,
+   ChangeMessageFlagState = 2,
+   MoveMessage = 3,
+   SaveDraft = 4,
+   SendMessage = 5,
+   CreateReplyMessage = 6,
+   CreateReplyAllMessage = 7,
+   CreateForwardMessage = 8,
+   MoveFolder = 9,
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxCapabilities {
+   InternalOofMessages = 1,
+   ExternalOofMessages = 2,
+   ServerSearch = 4,
+   AllFoldersServerSearch = 8,
+   SubFolderServerSearch = 16,
+   SmartReply = 32,
+   Irm = 64,
+   CanResolveRecipients = 128,
+   CanValidateCertificates = 256,
+   CanCreateMeetings = 512,
+   CanForwardMeetings = 1024,
+   CanRespondToMeetings = 2048,
+   CanSendNewTimeProposals = 4096,
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxChange {
+   public EmailMailboxChangeType ChangeType { get; }
+   public EmailFolder Folder { get; }
+   public IVector<EmailMailboxAction> MailboxActions { get; }
+   public EmailMessage Message { get; }
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxChangeReader {
+   public void AcceptChanges();
+   public void AcceptChangesThrough( EmailMailboxChange lastChangeToAcknowledge );
+   public IAsyncOperation<IVectorView<EmailMailboxChange>> ReadBatchAsync();
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxChangeTracker {
+   public bool IsTracking { get; }
+   public void Enable();
+   public EmailMailboxChangeReader GetChangeReader();
+   public void Reset();
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxChangeType {
+   MessageCreated = 0,
+   MessageModified = 1,
+   MessageDeleted = 2,
+   FolderCreated = 3,
+   FolderModified = 4,
+   FolderDeleted = 5,
+   ChangeTrackingLost = 6,
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxChangedDeferral {
+   public void Complete();
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs {
+   public EmailMailboxChangedDeferral GetDeferral();
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxOtherAppReadAccess {
+   SystemOnly = 0,
+   Full = 1,
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxOtherAppWriteAccess {
+   None = 0,
+   Limited = 1,
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxSyncAdapter {
+   public EmailMailboxSyncState CurrentState { get; }
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+   public IAsyncOperation<bool> SyncAsync();
+   TypedEventHandler<EmailMailbox, EmailMailboxSyncStatusChangedEventArgs> SyncStatusChanged;
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxSyncState {
+   Unknown = 0,
+   Idle = 1,
+   Syncing = 2,
+   Disconnected = 3,
+   Throttled = 4,
+   UserAttentionRequired = 5,
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxSyncStatus {
+   Success = 0,
+   AuthenticationError = 1,
+   UnknownError = 2,
+   NoConnectivity = 3,
+ }

+ public class Windows.ApplicationModel.Email.EmailMailboxSyncStatusChangedEventArgs {
+   public EmailMailboxSyncState CurrentState { get; }
+   public DateTime LastAttemptedSyncTime { get; }
+   public DateTime LastSuccessfulSyncTime { get; }
+ }

+ public enum Windows.ApplicationModel.Email.EmailMailboxType {
+   Email = 0,
+   VisualVoiceMail = 1,
+ }

| public class Windows.ApplicationModel.Email.EmailManager {
+   public static IAsyncOperation<EmailStore> RequestStoreAsync( EmailStoreAccessType result );
| }

+ public class Windows.ApplicationModel.Email.EmailMeetingInfo {
+   public bool IsResponseRequested { get; set; }
+   public bool IsAllDay { get; set; }
+   public TimeSpan Duration { get; set; }
+   public string AppointmentRoamingId { get; set; }
+   public IReference<DateTime> AppointmentOriginalStartTime { get; set; }
+   public bool AllowNewTimeProposal { get; set; }
+   public string Location { get; set; }
+   public DateTime StartTime { get; set; }
+   public ulong ServerChangeNumber { get; set; }
+   public IReference<DateTime> RecurrenceStartTime { get; set; }
+   public AppointmentRecurrence Recurrence { get; set; }
+   public IReference<DateTime> ProposedStartTime { get; set; }
+   public IReference<TimeSpan> ProposedDuration { get; set; }
+   public EmailMeetingInfo();
+ }

+ public enum Windows.ApplicationModel.Email.EmailMeetingResponseType {
+   Accept = 0,
+   Decline = 1,
+   Tentative = 2,
+   Cancel = 3,
+ }

| public class Windows.ApplicationModel.Email.EmailMessage {
+   public EmailIrmPermissions IrmPermissions { get; set; }
+   public EmailFlagState FlagState { get; set; }
+   public IReference<DateTime> IrmExpiration { get; set; }
+   public EmailClassification Classification { get; set; }
+   public EmailImportance Importance { get; set; }
+   public bool AllowInternetImage { get; set; }
+   public string RemoteId { get; set; }
+   public uint MessageSize { get; set; }
+   public string MessageClass { get; set; }
+   public EmailMeetingInfo MeetingInfo { get; set; }
+   public bool IsSeen { get; set; }
+   public bool IsRead { get; set; }
+   public EmailIrmTemplate IrmTemplate { get; set; }
+   public IReference<DateTime> SentTime { get; set; }
+   public EmailRecipient Sender { get; set; }
+   public EmailMessageResponseType ResponseType { get; set; }
+   public string Preview { get; set; }
+   public uint PreferredCodePage { get; set; }
+   public bool IsDraftMessage { get; }
+   public string NormalizedSubject { get; }
+   public uint OriginalCodePage { get; }
+   public ulong ChangeNumber { get; }
+   public string ConversationId { get; }
+   public bool IsTruncated { get; }
+   public string MailboxId { get; }
+   public string FolderId { get; }
+   public string Id { get; }
+   public uint TransportCodePage { get; }
+   public IRandomAccessStreamReference GetBodyStream( EmailMessageBodyType result );
+   public void SetBodyStream( EmailMessageBodyType type, IRandomAccessStreamReference stream );
| }

+ public class Windows.ApplicationModel.Email.EmailMessageBatch {
+   public IVectorView<EmailMessage> Messages { get; }
+   public EmailBatchStatus Status { get; }
+ }

+ public enum Windows.ApplicationModel.Email.EmailMessageBodyType {
+   Html = 0,
+   PlainText = 1,
+ }

+ public class Windows.ApplicationModel.Email.EmailMessageReader {
+   public IAsyncOperation<EmailMessageBatch> ReadBatchAsync();
+ }

+ public enum Windows.ApplicationModel.Email.EmailMessageResponseType {
+   None = 0,
+   Reply = 1,
+   ReplyAll = 2,
+   Forward = 3,
+ }

+ public enum Windows.ApplicationModel.Email.EmailMessageTypeFilter {
+   All = 0,
+   Important = 1,
+   Flagged = 2,
+   Unread = 3,
+   Read = 4,
+   Unseen = 5,
+ }

| public class Windows.ApplicationModel.Email.EmailRecipient {
+   public EmailRecipientAddressType AddressType { get; set; }
| }

+ public enum Windows.ApplicationModel.Email.EmailRecipientAddressType {
+   Email = 0,
+   Sms = 1,
+ }

+ public enum Windows.ApplicationModel.Email.EmailSearchFields {
+   None = 0,
+   Subject = 1,
+   Sender = 2,
+   Preview = 4,
+   Recipients = 8,
+   All = 4294967295,
+ }

+ public enum Windows.ApplicationModel.Email.EmailSortDirection {
+   Descending = 0,
+   Ascending = 1,
+ }

+ public enum Windows.ApplicationModel.Email.EmailSortProperty {
+   Date = 0,
+ }

+ public enum Windows.ApplicationModel.Email.EmailSpecialFolderType {
+   None = 0,
+   Root = 1,
+   Inbox = 2,
+   Outbox = 3,
+   Drafts = 4,
+   Deleted = 5,
+   Sent = 6,
+ }

+ public class Windows.ApplicationModel.Email.EmailStore {
+   public IAsyncOperation<IVectorView<EmailMailbox>> FindMailboxesAsync();
+   public EmailConversationReader GetConversationReader();
+   public EmailConversationReader GetConversationReader( EmailFetchOptions result );
+   public EmailMessageReader GetMessageReader();
+   public EmailMessageReader GetMessageReader( EmailFetchOptions result );
+   public IAsyncOperation<EmailMailbox> GetMailboxAsync( string result );
+   public IAsyncOperation<EmailConversation> GetConversationAsync( string result );
+   public IAsyncOperation<EmailFolder> GetFolderAsync( string result );
+   public IAsyncOperation<EmailMessage> GetMessageAsync( string result );
+   public IAsyncOperation<EmailMailbox> CreateMailboxAsync( string result, string accountName );
+ }

+ public enum Windows.ApplicationModel.Email.EmailStoreAccessType {
+   AppMailboxesReadWrite = 0,
+   AllMailboxesLimitedReadWrite = 1,
+ }

+ public class Windows.ApplicationModel.Email.EmailStoreNotificationTriggerDetails {
+ }

+ public enum Windows.ApplicationModel.Email.SmimeEncryptionAlgorithm {
+   Any = 0,
+   TripleDES = 1,
+   DES = 2,
+   RC2128bit = 3,
+   RC264bit = 4,
+   RC240bit = 5,
+ }

+ public enum Windows.ApplicationModel.Email.SmimeSigningAlgorithm {
+   Any = 0,
+   SHA1 = 1,
+   MD5 = 2,
+ }

+ public class Windows.ApplicationModel.LockScreen.LockApplicationHost {
+   public void RequestUnlock();
+   public static LockApplicationHost GetForCurrentView();
+   TypedEventHandler<LockApplicationHost, LockScreenUnlockingEventArgs> Unlocking;
+ }

+ public class Windows.ApplicationModel.LockScreen.LockScreenBadge {
+   public string AutomationName { get; }
+   public IRandomAccessStream Glyph { get; }
+   public IRandomAccessStream Logo { get; }
+   public IReference<uint> Number { get; }
+   public void LaunchApp();
+ }

+ public class Windows.ApplicationModel.LockScreen.LockScreenInfo {
+   public IRandomAccessStream AlarmIcon { get; }
+   public IVectorView<LockScreenBadge> Badges { get; }
+   public IVectorView<string> DetailText { get; }
+   public IRandomAccessStream LockScreenImage { get; }
+   TypedEventHandler<LockScreenInfo, object> AlarmIconChanged;
+   TypedEventHandler<LockScreenInfo, object> BadgesChanged;
+   TypedEventHandler<LockScreenInfo, object> DetailTextChanged;
+   TypedEventHandler<LockScreenInfo, object> LockScreenImageChanged;
+ }

+ public class Windows.ApplicationModel.LockScreen.LockScreenUnlockingDeferral {
+   public void Complete();
+ }

+ public class Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs {
+   public DateTime Deadline { get; }
+   public LockScreenUnlockingDeferral GetDeferral();
+ }

| public class Windows.ApplicationModel.Resources.Core.ResourceCandidate {
+   public IAsyncOperation<IRandomAccessStream> GetValueAsStreamAsync();
| }

+ public struct Windows.ApplicationModel.Resources.Core.ResourceLayoutInfo {
+   public uint MajorVersion;
+   public uint MinorVersion;
+   public uint ResourceSubtreeCount;
+   public uint NamedResourceCount;
+   public int Checksum;
+ }

| public class Windows.ApplicationModel.Resources.Core.ResourceManager {
+   public IVectorView<NamedResource> GetAllNamedResourcesForPackage( string table, ResourceLayoutInfo packageName );
+   public IVectorView<ResourceMap> GetAllSubtreesForPackage( string table, ResourceLayoutInfo packageName );
| }

+ public class Windows.ApplicationModel.Search.LocalContentSuggestionSettings {
+   public bool Enabled { get; set; }
+   public string AqsFilter { get; set; }
+   public IVector<StorageFolder> Locations { get; }
+   public IVector<string> PropertiesToMatch { get; }
+   public LocalContentSuggestionSettings();
+ }

+ public class Windows.ApplicationModel.Search.SearchQueryLinguisticDetails {
+   public IVectorView<string> QueryTextAlternatives { get; }
+   public uint QueryTextCompositionLength { get; }
+   public uint QueryTextCompositionStart { get; }
+   public SearchQueryLinguisticDetails( IIterable<string> queryTextAlternatives, uint queryTextCompositionStart, uint queryTextCompositionLength );
+ }

+ public class Windows.ApplicationModel.Search.SearchSuggestionCollection {
+   public uint Size { get; }
+   public void AppendQuerySuggestion( string text );
+   public void AppendQuerySuggestions( IIterable<string> suggestions );
+   public void AppendResultSuggestion( string text, string detailText, string tag, IRandomAccessStreamReference image, string imageAlternateText );
+   public void AppendSearchSeparator( string label );
+ }

+ public class Windows.ApplicationModel.Search.SearchSuggestionsRequest {
+   public bool IsCanceled { get; }
+   public SearchSuggestionCollection SearchSuggestionCollection { get; }
+   public SearchSuggestionsRequestDeferral GetDeferral();
+ }

+ public class Windows.ApplicationModel.Search.SearchSuggestionsRequestDeferral {
+   public void Complete();
+ }

| public class Windows.Data.Json.JsonArray {
+   public string ToString();
| }

| public class Windows.Data.Json.JsonObject {
+   public string ToString();
| }

| public class Windows.Data.Json.JsonValue {
+   public string ToString();
+   public static JsonValue CreateNullValue();
| }

+ public enum Windows.Data.Text.AlternateNormalizationFormat {
+   NotNormalized = 0,
+   Number = 1,
+   Currency = 3,
+   Date = 4,
+   Time = 5,
+ }

+ public class Windows.Data.Text.AlternateWordForm {
+   public string AlternateText { get; }
+   public AlternateNormalizationFormat NormalizationFormat { get; }
+   public TextSegment SourceTextSegment { get; }
+ }

+ public class Windows.Data.Text.SelectableWordSegment {
+   public TextSegment SourceTextSegment { get; }
+   public string Text { get; }
+ }

+ public void delegate Windows.Data.Text.SelectableWordSegmentsTokenizingHandler( IIterable<SelectableWordSegment> precedingWords, IIterable<SelectableWordSegment> words );

+ public class Windows.Data.Text.SelectableWordsSegmenter {
+   public string ResolvedLanguage { get; }
+   public SelectableWordsSegmenter( string language );
+   public SelectableWordSegment GetTokenAt( string result, uint text );
+   public IVectorView<SelectableWordSegment> GetTokens( string result );
+   public void Tokenize( string text, uint startIndex, SelectableWordSegmentsTokenizingHandler handler );
+ }

+ public class Windows.Data.Text.TextConversionGenerator {
+   public string ResolvedLanguage { get; }
+   public TextConversionGenerator( string languageTag );
+   public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result );
+   public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result, uint input );
+ }

+ public class Windows.Data.Text.TextPredictionGenerator {
+   public string ResolvedLanguage { get; }
+   public TextPredictionGenerator( string languageTag );
+   public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result );
+   public IAsyncOperation<IVectorView<string>> GetCandidatesAsync( string result, uint input );
+ }

+ public class Windows.Data.Text.TextReverseConversionGenerator {
+   public string ResolvedLanguage { get; }
+   public TextReverseConversionGenerator( string languageTag );
+   public IAsyncOperation<string> ConvertBackAsync( string result );
+ }

+ public class Windows.Data.Text.WordSegment {
+   public IVectorView<AlternateWordForm> AlternateForms { get; }
+   public TextSegment SourceTextSegment { get; }
+   public string Text { get; }
+ }

+ public void delegate Windows.Data.Text.WordSegmentsTokenizingHandler( IIterable<WordSegment> precedingWords, IIterable<WordSegment> words );

+ public class Windows.Data.Text.WordsSegmenter {
+   public string ResolvedLanguage { get; }
+   public WordsSegmenter( string language );
+   public WordSegment GetTokenAt( string result, uint text );
+   public IVectorView<WordSegment> GetTokens( string result );
+   public void Tokenize( string text, uint startIndex, WordSegmentsTokenizingHandler handler );
+ }

| public class Windows.Data.Xml.Dom.XmlDocument {
+   public void LoadXmlFromBuffer( IBuffer buffer );
+   public void LoadXmlFromBuffer( IBuffer buffer, XmlLoadSettings loadSettings );
+   public XmlDocument CloneDocument();
| }

| public class Windows.Data.Xml.Xsl.XsltProcessor {
+   public XmlDocument TransformToDocument( IXmlNode output );
| }

+ public enum Windows.Devices.Bluetooth.BluetoothError {
+   Success = 0,
+   RadioNotAvailable = 1,
+   ResourceInUse = 2,
+   DeviceNotConnected = 3,
+ }

+ public class Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter {
+   public IReference<TimeSpan> SamplingInterval { get; set; }
+   public IReference<TimeSpan> OutOfRangeTimeout { get; set; }
+   public IReference<short> OutOfRangeThresholdInDBm { get; set; }
+   public IReference<short> InRangeThresholdInDBm { get; set; }
+   public BluetoothSignalStrengthFilter();
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement {
+   public string LocalName { get; set; }
+   public IReference<BluetoothLEAdvertisementFlags> Flags { get; set; }
+   public IVector<BluetoothLEAdvertisementDataSection> DataSections { get; }
+   public IVector<BluetoothLEManufacturerData> ManufacturerData { get; }
+   public IVector<Guid> ServiceUuids { get; }
+   public BluetoothLEAdvertisement();
+   public IVectorView<BluetoothLEManufacturerData> GetManufacturerDataByCompanyId( ushort dataList );
+   public IVectorView<BluetoothLEAdvertisementDataSection> GetSectionsByType( byte sectionList );
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementBytePattern {
+   public short Offset { get; set; }
+   public byte DataType { get; set; }
+   public IBuffer Data { get; set; }
+   public BluetoothLEAdvertisementBytePattern();
+   public BluetoothLEAdvertisementBytePattern( byte dataType, short offset, IBuffer data );
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection {
+   public byte DataType { get; set; }
+   public IBuffer Data { get; set; }
+   public BluetoothLEAdvertisementDataSection();
+   public BluetoothLEAdvertisementDataSection( byte dataType, IBuffer data );
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataTypes {
+   public byte AdvertisingInterval { get; }
+   public byte Appearance { get; }
+   public byte CompleteLocalName { get; }
+   public byte CompleteService128BitUuids { get; }
+   public byte CompleteService16BitUuids { get; }
+   public byte CompleteService32BitUuids { get; }
+   public byte Flags { get; }
+   public byte IncompleteService128BitUuids { get; }
+   public byte IncompleteService16BitUuids { get; }
+   public byte IncompleteService32BitUuids { get; }
+   public byte ManufacturerSpecificData { get; }
+   public byte PublicTargetAddress { get; }
+   public byte RandomTargetAddress { get; }
+   public byte ServiceData128BitUuids { get; }
+   public byte ServiceData16BitUuids { get; }
+   public byte ServiceData32BitUuids { get; }
+   public byte ServiceSolicitation128BitUuids { get; }
+   public byte ServiceSolicitation16BitUuids { get; }
+   public byte ServiceSolicitation32BitUuids { get; }
+   public byte ShortenedLocalName { get; }
+   public byte SlaveConnectionIntervalRange { get; }
+   public byte TxPowerLevel { get; }
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter {
+   public BluetoothLEAdvertisement Advertisement { get; set; }
+   public IVector<BluetoothLEAdvertisementBytePattern> BytePatterns { get; }
+   public BluetoothLEAdvertisementFilter();
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFlags {
+   None = 0,
+   LimitedDiscoverableMode = 1,
+   GeneralDiscoverableMode = 2,
+   ClassicNotSupported = 4,
+   DualModeControllerCapable = 8,
+   DualModeHostCapable = 16,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher {
+   public BluetoothLEAdvertisement Advertisement { get; }
+   public BluetoothLEAdvertisementPublisherStatus Status { get; }
+   public BluetoothLEAdvertisementPublisher();
+   public BluetoothLEAdvertisementPublisher( BluetoothLEAdvertisement advertisement );
+   public void Start();
+   public void Stop();
+   TypedEventHandler<BluetoothLEAdvertisementPublisher, BluetoothLEAdvertisementPublisherStatusChangedEventArgs> StatusChanged;
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatus {
+   Created = 0,
+   Waiting = 1,
+   Started = 2,
+   Stopping = 3,
+   Stopped = 4,
+   Aborted = 5,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs {
+   public BluetoothError Error { get; }
+   public BluetoothLEAdvertisementPublisherStatus Status { get; }
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs {
+   public BluetoothLEAdvertisement Advertisement { get; }
+   public BluetoothLEAdvertisementType AdvertisementType { get; }
+   public ulong BluetoothAddress { get; }
+   public string DeviceId { get; }
+   public short RawSignalStrengthInDBm { get; }
+   public DateTime Timestamp { get; }
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementType {
+   ConnectableUndirected = 0,
+   ConnectableDirected = 1,
+   ScannableUndirected = 2,
+   NonConnectableUndirected = 3,
+   ScanResponse = 4,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher {
+   public BluetoothSignalStrengthFilter SignalStrengthFilter { get; set; }
+   public BluetoothLEScanningMode ScanningMode { get; set; }
+   public BluetoothLEAdvertisementFilter AdvertisementFilter { get; set; }
+   public TimeSpan MaxOutOfRangeTimeout { get; }
+   public TimeSpan MaxSamplingInterval { get; }
+   public TimeSpan MinOutOfRangeTimeout { get; }
+   public TimeSpan MinSamplingInterval { get; }
+   public BluetoothLEAdvertisementWatcherStatus Status { get; }
+   public BluetoothLEAdvertisementWatcher();
+   public BluetoothLEAdvertisementWatcher( BluetoothLEAdvertisementFilter advertisementFilter );
+   public void Start();
+   public void Stop();
+   TypedEventHandler<BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementReceivedEventArgs> Received;
+   TypedEventHandler<BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementWatcherStoppedEventArgs> Stopped;
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStatus {
+   Created = 0,
+   Started = 1,
+   Stopping = 2,
+   Stopped = 3,
+   Aborted = 4,
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs {
+   public BluetoothError Error { get; }
+ }

+ public class Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData {
+   public IBuffer Data { get; set; }
+   public ushort CompanyId { get; set; }
+   public BluetoothLEManufacturerData();
+   public BluetoothLEManufacturerData( ushort companyId, IBuffer data );
+ }

+ public enum Windows.Devices.Bluetooth.Advertisement.BluetoothLEScanningMode {
+   Passive = 0,
+   Active = 1,
+ }

+ public class Windows.Devices.Bluetooth.Background.BluetoothLEAdvertisementPublisherTriggerDetails {
+   public BluetoothError Error { get; }
+   public BluetoothLEAdvertisementPublisherStatus Status { get; }
+ }

+ public class Windows.Devices.Bluetooth.Background.BluetoothLEAdvertisementWatcherTriggerDetails {
+   public IVectorView<BluetoothLEAdvertisementReceivedEventArgs> Advertisements { get; }
+   public BluetoothError Error { get; }
+   public BluetoothSignalStrengthFilter SignalStrengthFilter { get; }
+ }

| public enum Windows.Devices.Enumeration.Pnp.PnpObjectType {
+   AssociationEndpoint = 5,
+   AssociationEndpointContainer = 6,
+   AssociationEndpointService = 7,
| }

+ public enum Windows.Devices.Geolocation.GeolocationAccessStatus {
+   Unspecified = 0,
+   Allowed = 1,
+   Denied = 2,
+ }

| public class Windows.Devices.Geolocation.Geolocator {
+   public static IAsyncOperation<GeolocationAccessStatus> RequestAccessAsync();
+   public static IAsyncOperation<IVectorView<Geoposition>> GetGeopositionHistoryAsync( DateTime result );
+   public static IAsyncOperation<IVectorView<Geoposition>> GetGeopositionHistoryAsync( DateTime result, TimeSpan startTime );
| }

| public class Windows.Devices.Geolocation.Geoposition {
+   public VenueData VenueData { get; }
| }

+ public class Windows.Devices.Geolocation.VenueData {
+   public string Id { get; }
+   public string Level { get; }
+ }

+ public class Windows.Devices.Lights.Lamp {
+   public bool IsEnabled { get; set; }
+   public Color Color { get; set; }
+   public float BrightnessLevel { get; set; }
+   public string DeviceId { get; }
+   public bool IsColorSettable { get; }
+   public void Close();
+   public static string GetDeviceSelector();
+   public static IAsyncOperation<Lamp> FromIdAsync( string operation );
+   public static IAsyncOperation<Lamp> GetDefaultAsync();
+   TypedEventHandler<Lamp, LampAvailabilityChangedEventArgs> AvailabilityChanged;
+ }

+ public class Windows.Devices.Lights.LampAvailabilityChangedEventArgs {
+   public bool IsAvailable { get; }
+ }

+ public class Windows.Devices.Power.Battery {
+   public string DeviceId { get; }
+   public Battery AggregateBattery { get; }
+   public BatteryReport GetReport();
+   public static IAsyncOperation<Battery> FromIdAsync( string result );
+   public static string GetDeviceSelector();
+   TypedEventHandler<Battery, object> ReportUpdated;
+ }

+ public class Windows.Devices.Power.BatteryReport {
+   public IReference<int> ChargeRateInMilliwatts { get; }
+   public IReference<int> DesignCapacityInMilliwattHours { get; }
+   public IReference<int> FullChargeCapacityInMilliwattHours { get; }
+   public IReference<int> RemainingCapacityInMilliwattHours { get; }
+   public BatteryStatus Status { get; }
+ }

| public class Windows.Devices.Sensors.Accelerometer {
+   public DisplayOrientations ReadingTransform { get; set; }
| }

+ public class Windows.Devices.Sensors.ActivitySensor {
+   public string DeviceId { get; }
+   public uint MinimumReportInterval { get; }
+   public double PowerInMilliwatts { get; }
+   public ActivitySensorStatus Status { get; }
+   public IVector<ActivityType> SubscribedActivities { get; }
+   public IVectorView<ActivityType> SupportedActivities { get; }
+   public IAsyncOperation<ActivitySensorReading> GetCurrentReadingAsync();
+   public static IAsyncOperation<ActivitySensor> GetDefaultAsync();
+   public static string GetDeviceSelector();
+   public static IAsyncOperation<ActivitySensor> FromIdAsync( string result );
+   public static IAsyncOperation<IVectorView<ActivitySensorReading>> GetSystemHistoryAsync( DateTime result );
+   public static IAsyncOperation<IVectorView<ActivitySensorReading>> GetSystemHistoryAsync( DateTime result, TimeSpan fromTime );
+   TypedEventHandler<ActivitySensor, ActivitySensorReadingChangedEventArgs> ReadingChanged;
+   TypedEventHandler<ActivitySensor, ActivitySensorStatusChangedEventArgs> StatusChanged;
+ }

+ public class Windows.Devices.Sensors.ActivitySensorReading {
+   public ActivityType Activity { get; }
+   public ActivitySensorReadingConfidence Confidence { get; }
+   public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.ActivitySensorReadingChangeReport {
+   public ActivitySensorReading Reading { get; }
+ }

+ public class Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs {
+   public ActivitySensorReading Reading { get; }
+ }

+ public enum Windows.Devices.Sensors.ActivitySensorReadingConfidence {
+   High = 0,
+   Low = 1,
+ }

+ public enum Windows.Devices.Sensors.ActivitySensorStatus {
+   Disabled = 0,
+   Enabled = 1,
+   Error = 2,
+ }

+ public class Windows.Devices.Sensors.ActivitySensorStatusChangedEventArgs {
+   public ActivitySensorStatus Status { get; }
+   public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.ActivitySensorTriggerDetails {
+   public IVectorView<ActivitySensorReadingChangeReport> ReadReports();
+ }

+ public enum Windows.Devices.Sensors.ActivityType {
+   Unknown = 0,
+   Stationary = 1,
+   Fidgeting = 2,
+   Walking = 3,
+   Running = 4,
+   InVehicle = 5,
+   Biking = 6,
+ }

+ public class Windows.Devices.Sensors.Altimeter {
+   public uint ReportInterval { get; set; }
+   public string DeviceId { get; }
+   public uint MinimumReportInterval { get; }
+   public AltimeterReading GetCurrentReading();
+   public static Altimeter GetDefault();
+   TypedEventHandler<Altimeter, AltimeterReadingChangedEventArgs> ReadingChanged;
+ }

+ public class Windows.Devices.Sensors.AltimeterReading {
+   public double AltitudeChangeInMeters { get; }
+   public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.AltimeterReadingChangedEventArgs {
+   public AltimeterReading Reading { get; }
+ }

+ public class Windows.Devices.Sensors.Barometer {
+   public uint ReportInterval { get; set; }
+   public string DeviceId { get; }
+   public uint MinimumReportInterval { get; }
+   public BarometerReading GetCurrentReading();
+   public static Barometer GetDefault();
+   TypedEventHandler<Barometer, BarometerReadingChangedEventArgs> ReadingChanged;
+ }

+ public class Windows.Devices.Sensors.BarometerReading {
+   public double StationPressureInHectopascals { get; }
+   public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.BarometerReadingChangedEventArgs {
+   public BarometerReading Reading { get; }
+ }

| public class Windows.Devices.Sensors.Compass {
+   public DisplayOrientations ReadingTransform { get; set; }
| }

| public class Windows.Devices.Sensors.Gyrometer {
+   public DisplayOrientations ReadingTransform { get; set; }
| }

+ public interface Windows.Devices.Sensors.ISensorDataThreshold {
+ }

| public class Windows.Devices.Sensors.Inclinometer {
+   public DisplayOrientations ReadingTransform { get; set; }
+   public SensorReadingType ReadingType { get; }
+   public static Inclinometer GetDefaultForRelativeReadings();
| }

| public class Windows.Devices.Sensors.Magnetometer {
+   public DisplayOrientations ReadingTransform { get; set; }
| }

| public class Windows.Devices.Sensors.OrientationSensor {
+   public DisplayOrientations ReadingTransform { get; set; }
+   public SensorReadingType ReadingType { get; }
+   public static OrientationSensor GetDefaultForRelativeReadings();
| }

+ public class Windows.Devices.Sensors.Pedometer {
+   public uint ReportInterval { get; set; }
+   public string DeviceId { get; }
+   public uint MinimumReportInterval { get; }
+   public double PowerInMilliwatts { get; }
+   public PedometerStatus Status { get; }
+   public IVectorView<PedometerReading> GetReadingsFromTriggerDetails( SensorDataThresholdTriggerDetails result );
+   public static IAsyncOperation<Pedometer> FromIdAsync( string operation );
+   public static IAsyncOperation<Pedometer> GetDefaultAsync();
+   public static string GetDeviceSelector();
+   public static IAsyncOperation<IVectorView<PedometerReading>> GetSystemHistoryAsync( DateTime operation );
+   public static IAsyncOperation<IVectorView<PedometerReading>> GetSystemHistoryAsync( DateTime operation, TimeSpan fromTime );
+   TypedEventHandler<Pedometer, PedometerReadingChangedEventArgs> ReadingChanged;
+   TypedEventHandler<Pedometer, PedometerStatusChangedEventArgs> StatusChanged;
+ }

+ public class Windows.Devices.Sensors.PedometerDataThreshold {
+ }

+ public class Windows.Devices.Sensors.PedometerReading {
+   public int CumulativeSteps { get; }
+   public PedometerStepKind StepKind { get; }
+   public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.PedometerReadingChangedEventArgs {
+   public PedometerReading Reading { get; }
+ }

+ public enum Windows.Devices.Sensors.PedometerStatus {
+   Disabled = 0,
+   Idle = 1,
+   Active = 2,
+   Error = 3,
+ }

+ public class Windows.Devices.Sensors.PedometerStatusChangedEventArgs {
+   public PedometerStatus Status { get; }
+ }

+ public enum Windows.Devices.Sensors.PedometerStepKind {
+   Unknown = 0,
+   Walking = 1,
+   Running = 2,
+ }

+ public class Windows.Devices.Sensors.ProximitySensor {
+   public string DeviceId { get; }
+   public IReference<uint> MaxDistanceInMillimeters { get; }
+   public IReference<uint> MinDistanceInMillimeters { get; }
+   public ProximitySensorReading GetCurrentReading();
+   public static string GetDeviceSelector();
+   public static ProximitySensor FromId( string result1 );
+   TypedEventHandler<ProximitySensor, ProximitySensorReadingChangedEventArgs> ReadingChanged;
+ }

+ public class Windows.Devices.Sensors.ProximitySensorReading {
+   public IReference<uint> DistanceInMillimeters { get; }
+   public bool IsDetected { get; }
+   public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs {
+   public ProximitySensorReading Reading { get; }
+ }

+ public class Windows.Devices.Sensors.SensorDataThresholdTriggerDetails {
+   public string DeviceId { get; }
+   public SensorType SensorType { get; }
+ }

+ public enum Windows.Devices.Sensors.SensorReadingType {
+   Absolute = 0,
+   Relative = 1,
+ }

+ public enum Windows.Devices.Sensors.SensorType {
+   Accelerometer = 0,
+   ActivitySensor = 1,
+   Barometer = 2,
+   Compass = 3,
+   CustomSensor = 4,
+   Gyroscope = 5,
+   ProximitySensor = 6,
+   Inclinometer = 7,
+   LightSensor = 8,
+   OrientationSensor = 9,
+   Pedometer = 10,
+   RelativeInclinometer = 11,
+   RelativeOrientationSensor = 12,
+   SimpleOrientationSensor = 13,
+ }

| public class Windows.Devices.Sensors.SimpleOrientationSensor {
+   public DisplayOrientations ReadingTransform { get; set; }
| }

+ public class Windows.Devices.Sensors.Custom.CustomSensor {
+   public uint ReportInterval { get; set; }
+   public string DeviceId { get; }
+   public uint MinimumReportInterval { get; }
+   public CustomSensorReading GetCurrentReading();
+   public static string GetDeviceSelector( Guid result );
+   public static IAsyncOperation<CustomSensor> FromIdAsync( string result );
+   TypedEventHandler<CustomSensor, CustomSensorReadingChangedEventArgs> ReadingChanged;
+ }

+ public class Windows.Devices.Sensors.Custom.CustomSensorReading {
+   public IMapView<string, object> Properties { get; }
+   public DateTime Timestamp { get; }
+ }

+ public class Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs {
+   public CustomSensorReading Reading { get; }
+ }

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

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

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

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

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

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

| public class Windows.Devices.SmartCards.SmartCardEmulator {
+   public void Start();
+   public bool IsHostCardEmulationSupported();
+   public static IAsyncOperation<IVectorView<SmartCardAppletIdGroupRegistration>> GetAppletIdGroupRegistrationsAsync();
+   public static IAsyncOperation<SmartCardAppletIdGroupRegistration> RegisterAppletIdGroupAsync( SmartCardAppletIdGroup result );
+   public static IAsyncAction UnregisterAppletIdGroupAsync( SmartCardAppletIdGroupRegistration result );
| }

+ public class Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs {
+   public IBuffer CommandApdu { get; }
+   public SmartCardEmulatorConnectionProperties ConnectionProperties { get; }
+   public IAsyncOperation<bool> TryRespondAsync( IBuffer result );
+ }

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

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

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

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

| public class Windows.Devices.SmartCards.SmartCardTriggerDetails {
+   public SmartCardEmulator Emulator { get; }
| }

| public enum Windows.Devices.SmartCards.SmartCardTriggerType {
+   EmulatorHostApplicationActivated = 3,
| }

+ public class Windows.Devices.WiFiDirect.WiFiDirectAdvertisement {
+   public WiFiDirectAdvertisementListenStateDiscoverability ListenStateDiscoverability { get; set; }
+   public bool IsAutonomousGroupOwnerEnabled { get; set; }
+   public IVector<WiFiDirectInformationElement> InformationElements { get; set; }
+ }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectAdvertisementListenStateDiscoverability {
+   None = 0,
+   Normal = 1,
+   Intensive = 2,
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher {
+   public WiFiDirectAdvertisement Advertisement { get; }
+   public WiFiDirectAdvertisementPublisherStatus Status { get; }
+   public void Start();
+   public void Stop();
+   TypedEventHandler<WiFiDirectAdvertisementPublisher, WiFiDirectAdvertisementPublisherStatusChangedEventArgs> StatusChanged;
+ }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatus {
+   Created = 0,
+   Started = 1,
+   Stopped = 2,
+   Aborted = 3,
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs {
+   public WiFiDirectError Error { get; }
+   public WiFiDirectAdvertisementPublisherStatus Status { get; }
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionListener {
+   TypedEventHandler<WiFiDirectConnectionListener, WiFiDirectConnectionRequestedEventArgs> ConnectionRequested;
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionParameters {
+   public short GroupOwnerIntent { get; set; }
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionRequest {
+   public DeviceInformation DeviceInformation { get; }
+   public void Close();
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs {
+   public WiFiDirectConnectionRequest GetConnectionRequest();
+ }

| public class Windows.Devices.WiFiDirect.WiFiDirectDevice {
+   public static string GetDeviceSelector( WiFiDirectDeviceSelectorType result );
+   public static IAsyncOperation<WiFiDirectDevice> FromIdAsync( string result, WiFiDirectConnectionParameters deviceId );
| }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectDeviceSelectorType {
+   DeviceInterface = 0,
+   AssociationEndpoint = 1,
+ }

+ public enum Windows.Devices.WiFiDirect.WiFiDirectError {
+   Success = 0,
+   RadioNotAvailable = 1,
+   ResourceInUse = 2,
+ }

+ public class Windows.Devices.WiFiDirect.WiFiDirectInformationElement {
+   public IBuffer Value { get; set; }
+   public byte OuiType { get; set; }
+   public IBuffer Oui { get; set; }
+   public static IVector<WiFiDirectInformationElement> CreateFromBuffer( IBuffer result );
+   public static IVector<WiFiDirectInformationElement> CreateFromDeviceInformation( DeviceInformation result );
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectService {
+   public IBuffer SessionInfo { get; set; }
+   public bool PreferGroupOwnerMode { get; set; }
+   public IBuffer RemoteServiceInfo { get; }
+   public WiFiDirectServiceError ServiceError { get; }
+   public IVectorView<WiFiDirectServiceConfigurationMethod> SupportedConfigurationMethods { get; }
+   public IAsyncOperation<WiFiDirectServiceProvisioningInfo> GetProvisioningInfoAsync( WiFiDirectServiceConfigurationMethod result );
+   public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync();
+   public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync( string result );
+   public static string GetSelector( string serviceSelector );
+   public static string GetSelector( string serviceSelector, IBuffer serviceName );
+   public static WiFiDirectService FromId( string wifiDirectService );
+   TypedEventHandler<WiFiDirectService, WiFiDirectServiceSessionDeferredEventArgs> SessionDeferred;
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertisementStatus {
+   Created = 0,
+   Started = 1,
+   Stopped = 2,
+   Aborted = 3,
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser {
+   public WiFiDirectServiceStatus ServiceStatus { get; set; }
+   public IBuffer ServiceInfo { get; set; }
+   public bool PreferGroupOwnerMode { get; set; }
+   public IBuffer DeferredSessionInfo { get; set; }
+   public uint CustomServiceStatusCode { get; set; }
+   public bool AutoAcceptSession { get; set; }
+   public WiFiDirectServiceAdvertisementStatus AdvertisementStatus { get; }
+   public IVector<WiFiDirectServiceConfigurationMethod> PreferredConfigurationMethods { get; }
+   public WiFiDirectServiceError ServiceError { get; }
+   public string ServiceName { get; }
+   public WiFiDirectServiceAdvertiser( string serviceName );
+   public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync( DeviceInformation result );
+   public IAsyncOperation<WiFiDirectServiceSession> ConnectAsync( DeviceInformation result, string deviceInfo );
+   public void Start();
+   public void Stop();
+   TypedEventHandler<WiFiDirectServiceAdvertiser, object> AdvertisementStatusChanged;
+   TypedEventHandler<WiFiDirectServiceAdvertiser, WiFiDirectServiceAutoAcceptSessionConnectedEventArgs> AutoAcceptSessionConnected;
+   TypedEventHandler<WiFiDirectServiceAdvertiser, WiFiDirectServiceSessionRequestedEventArgs> SessionRequested;
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs {
+   public WiFiDirectServiceSession Session { get; }
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceConfigurationMethod {
+   Default = 0,
+   PinDisplay = 1,
+   PinEntry = 2,
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceError {
+   Success = 0,
+   RadioNotAvailable = 1,
+   ResourceInUse = 2,
+   UnsupportedHardware = 3,
+   NoHardware = 4,
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceIPProtocol {
+   Tcp = 6,
+   Udp = 17,
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceProvisioningInfo {
+   public bool IsGroupFormationNeeded { get; }
+   public WiFiDirectServiceConfigurationMethod SelectedConfigurationMethod { get; }
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs {
+   public IVectorView<EndpointPair> EndpointPairs { get; }
+   public WiFiDirectServiceIPProtocol Protocol { get; }
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession {
+   public uint AdvertisementId { get; }
+   public WiFiDirectServiceSessionErrorStatus ErrorStatus { get; }
+   public string ServiceAddress { get; }
+   public string ServiceName { get; }
+   public string SessionAddress { get; }
+   public uint SessionId { get; }
+   public WiFiDirectServiceSessionStatus Status { get; }
+   public IVectorView<EndpointPair> GetConnectionEndpointPairs();
+   public IAsyncAction AddStreamSocketListenerAsync( StreamSocketListener result );
+   public IAsyncAction AddDatagramSocketAsync( DatagramSocket result );
+   public void Close();
+   TypedEventHandler<WiFiDirectServiceSession, WiFiDirectServiceRemotePortAddedEventArgs> RemotePortAdded;
+   TypedEventHandler<WiFiDirectServiceSession, object> SessionStatusChanged;
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs {
+   public IBuffer DeferredSessionInfo { get; }
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionErrorStatus {
+   Ok = 0,
+   Disassociated = 1,
+   LocalClose = 2,
+   RemoteClose = 3,
+   SystemFailure = 4,
+   NoResponseFromRemote = 5,
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequest {
+   public DeviceInformation DeviceInformation { get; }
+   public WiFiDirectServiceProvisioningInfo ProvisioningInfo { get; }
+   public IBuffer SessionInfo { get; }
+   public void Close();
+ }

+ public class Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs {
+   public WiFiDirectServiceSessionRequest GetSessionRequest();
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionStatus {
+   Closed = 0,
+   Initiated = 1,
+   Requested = 2,
+   Open = 3,
+ }

+ public enum Windows.Devices.WiFiDirect.Services.WiFiDirectServiceStatus {
+   Available = 0,
+   Busy = 1,
+   Custom = 2,
+ }

+ public class Windows.Foundation.Deferral {
+   public Deferral( DeferralCompletedHandler handler );
+   public void Complete();
+   public void Close();
+ }

+ public void delegate Windows.Foundation.DeferralCompletedHandler();

+ public interface Windows.Foundation.Diagnostics.ILoggingTarget {
+   public bool IsEnabled();
+   public bool IsEnabled( LoggingLevel result );
+   public bool IsEnabled( LoggingLevel result, long level );
+   public void LogEvent( string eventName );
+   public void LogEvent( string eventName, LoggingFields fields );
+   public void LogEvent( string eventName, LoggingFields fields, LoggingLevel level );
+   public void LogEvent( string eventName, LoggingFields fields, LoggingLevel level, LoggingOptions options );
+   public LoggingActivity StartActivity( string result );
+   public LoggingActivity StartActivity( string result, LoggingFields startEventName );
+   public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields );
+   public LoggingActivity StartActivity( string result, LoggingFields startEventName, LoggingLevel fields, LoggingOptions level );
+ }

| public class Windows.Foundation.Diagnostics.LoggingChannel {
+   public LoggingChannel( string name, LoggingChannelOptions options );
+   public LoggingChannel( string name, LoggingChannelOptions options, Guid id );
| }

+ public class Windows.Foundation.Diagnostics.LoggingChannelOptions {
+   public Guid Group { get; set; }
+   public LoggingChannelOptions( Guid group );
+   public LoggingChannelOptions();
+ }

+ public enum Windows.Foundation.Diagnostics.LoggingFieldFormat {
+   Default = 0,
+   Hidden = 1,
+   String = 2,
+   Boolean = 3,
+   Hexadecimal = 4,
+   ProcessId = 5,
+   ThreadId = 6,
+   Port = 7,
+   Ipv4Address = 8,
+   Ipv6Address = 9,
+   SocketAddress = 10,
+   Xml = 11,
+   Json = 12,
+   Win32Error = 13,
+   NTStatus = 14,
+   HResult = 15,
+   FileTime = 16,
+   Signed = 17,
+   Unsigned = 18,
+ }

+ public class Windows.Foundation.Diagnostics.LoggingFields {
+   public LoggingFields();
+   public void Clear();
+   public void BeginStruct( string name );
+   public void BeginStruct( string name, int tags );
+   public void EndStruct();
+   public void AddEmpty( string name );
+   public void AddEmpty( string name, LoggingFieldFormat format );
+   public void AddEmpty( string name, LoggingFieldFormat format, int tags );
+   public void AddUInt8( string name, byte value );
+   public void AddUInt8( string name, byte value, LoggingFieldFormat format );
+   public void AddUInt8( string name, byte value, LoggingFieldFormat format, int tags );
+   public void AddUInt8Array( string name, byte[] value );
+   public void AddUInt8Array( string name, byte[] value, LoggingFieldFormat format );
+   public void AddUInt8Array( string name, byte[] value, LoggingFieldFormat format, int tags );
+   public void AddInt16( string name, short value );
+   public void AddInt16( string name, short value, LoggingFieldFormat format );
+   public void AddInt16( string name, short value, LoggingFieldFormat format, int tags );
+   public void AddInt16Array( string name, short[] value );
+   public void AddInt16Array( string name, short[] value, LoggingFieldFormat format );
+   public void AddInt16Array( string name, short[] value, LoggingFieldFormat format, int tags );
+   public void AddUInt16( string name, ushort value );
+   public void AddUInt16( string name, ushort value, LoggingFieldFormat format );
+   public void AddUInt16( string name, ushort value, LoggingFieldFormat format, int tags );
+   public void AddUInt16Array( string name, ushort[] value );
+   public void AddUInt16Array( string name, ushort[] value, LoggingFieldFormat format );
+   public void AddUInt16Array( string name, ushort[] value, LoggingFieldFormat format, int tags );
+   public void AddInt32( string name, int value );
+   public void AddInt32( string name, int value, LoggingFieldFormat format );
+   public void AddInt32( string name, int value, LoggingFieldFormat format, int tags );
+   public void AddInt32Array( string name, int[] value );
+   public void AddInt32Array( string name, int[] value, LoggingFieldFormat format );
+   public void AddInt32Array( string name, int[] value, LoggingFieldFormat format, int tags );
+   public void AddUInt32( string name, uint value );
+   public void AddUInt32( string name, uint value, LoggingFieldFormat format );
+   public void AddUInt32( string name, uint value, LoggingFieldFormat format, int tags );
+   public void AddUInt32Array( string name, uint[] value );
+   public void AddUInt32Array( string name, uint[] value, LoggingFieldFormat format );
+   public void AddUInt32Array( string name, uint[] value, LoggingFieldFormat format, int tags );
+   public void AddInt64( string name, long value );
+   public void AddInt64( string name, long value, LoggingFieldFormat format );
+   public void AddInt64( string name, long value, LoggingFieldFormat format, int tags );
+   public void AddInt64Array( string name, long[] value );
+   public void AddInt64Array( string name, long[] value, LoggingFieldFormat format );
+   public void AddInt64Array( string name, long[] value, LoggingFieldFormat format, int tags );
+   public void AddUInt64( string name, ulong value );
+   public void AddUInt64( string name, ulong value, LoggingFieldFormat format );
+   public void AddUInt64( string name, ulong value, LoggingFieldFormat format, int tags );
+   public void AddUInt64Array( string name, ulong[] value );
+   public void AddUInt64Array( string name, ulong[] value, LoggingFieldFormat format );
+   public void AddUInt64Array( string name, ulong[] value, LoggingFieldFormat format, int tags );
+   public void AddSingle( string name, float value );
+   public void AddSingle( string name, float value, LoggingFieldFormat format );
+   public void AddSingle( string name, float value, LoggingFieldFormat format, int tags );
+   public void AddSingleArray( string name, float[] value );
+   public void AddSingleArray( string name, float[] value, LoggingFieldFormat format );
+   public void AddSingleArray( string name, float[] value, LoggingFieldFormat format, int tags );
+   public void AddDouble( string name, double value );
+   public void AddDouble( string name, double value, LoggingFieldFormat format );
+   public void AddDouble( string name, double value, LoggingFieldFormat format, int tags );
+   public void AddDoubleArray( string name, double[] value );
+   public void AddDoubleArray( string name, double[] value, LoggingFieldFormat format );
+   public void AddDoubleArray( string name, double[] value, LoggingFieldFormat format, int tags );
+   public void AddChar16( string name, char value );
+   public void AddChar16( string name, char value, LoggingFieldFormat format );
+   public void AddChar16( string name, char value, LoggingFieldFormat format, int tags );
+   public void AddChar16Array( string name, char[] value );
+   public void AddChar16Array( string name, char[] value, LoggingFieldFormat format );
+   public void AddChar16Array( string name, char[] value, LoggingFieldFormat format, int tags );
+   public void AddBoolean( string name, bool value );
+   public void AddBoolean( string name, bool value, LoggingFieldFormat format );
+   public void AddBoolean( string name, bool value, LoggingFieldFormat format, int tags );
+   public void AddBooleanArray( string name, bool[] value );
+   public void AddBooleanArray( string name, bool[] value, LoggingFieldFormat format );
+   public void AddBooleanArray( string name, bool[] value, LoggingFieldFormat format, int tags );
+   public void AddString( string name, string value );
+   public void AddString( string name, string value, LoggingFieldFormat format );
+   public void AddString( string name, string value, LoggingFieldFormat format, int tags );
+   public void AddStringArray( string name, string[] value );
+   public void AddStringArray( string name, string[] value, LoggingFieldFormat format );
+   public void AddStringArray( string name, string[] value, LoggingFieldFormat format, int tags );
+   public void AddGuid( string name, Guid value );
+   public void AddGuid( string name, Guid value, LoggingFieldFormat format );
+   public void AddGuid( string name, Guid value, LoggingFieldFormat format, int tags );
+   public void AddGuidArray( string name, Guid[] value );
+   public void AddGuidArray( string name, Guid[] value, LoggingFieldFormat format );
+   public void AddGuidArray( string name, Guid[] value, LoggingFieldFormat format, int tags );
+   public void AddDateTime( string name, DateTime value );
+   public void AddDateTime( string name, DateTime value, LoggingFieldFormat format );
+   public void AddDateTime( string name, DateTime value, LoggingFieldFormat format, int tags );
+   public void AddDateTimeArray( string name, DateTime[] value );
+   public void AddDateTimeArray( string name, DateTime[] value, LoggingFieldFormat format );
+   public void AddDateTimeArray( string name, DateTime[] value, LoggingFieldFormat format, int tags );
+   public void AddTimeSpan( string name, TimeSpan value );
+   public void AddTimeSpan( string name, TimeSpan value, LoggingFieldFormat format );
+   public void AddTimeSpan( string name, TimeSpan value, LoggingFieldFormat format, int tags );
+   public void AddTimeSpanArray( string name, TimeSpan[] value );
+   public void AddTimeSpanArray( string name, TimeSpan[] value, LoggingFieldFormat format );
+   public void AddTimeSpanArray( string name, TimeSpan[] value, LoggingFieldFormat format, int tags );
+   public void AddPoint( string name, Point value );
+   public void AddPoint( string name, Point value, LoggingFieldFormat format );
+   public void AddPoint( string name, Point value, LoggingFieldFormat format, int tags );
+   public void AddPointArray( string name, Point[] value );
+   public void AddPointArray( string name, Point[] value, LoggingFieldFormat format );
+   public void AddPointArray( string name, Point[] value, LoggingFieldFormat format, int tags );
+   public void AddSize( string name, Size value );
+   public void AddSize( string name, Size value, LoggingFieldFormat format );
+   public void AddSize( string name, Size value, LoggingFieldFormat format, int tags );
+   public void AddSizeArray( string name, Size[] value );
+   public void AddSizeArray( string name, Size[] value, LoggingFieldFormat format );
+   public void AddSizeArray( string name, Size[] value, LoggingFieldFormat format, int tags );
+   public void AddRect( string name, Rect value );
+   public void AddRect( string name, Rect value, LoggingFieldFormat format );
+   public void AddRect( string name, Rect value, LoggingFieldFormat format, int tags );
+   public void AddRectArray( string name, Rect[] value );
+   public void AddRectArray( string name, Rect[] value, LoggingFieldFormat format );
+   public void AddRectArray( string name, Rect[] value, LoggingFieldFormat format, int tags );
+ }

+ public enum Windows.Foundation.Diagnostics.LoggingOpcode {
+   Info = 0,
+   Start = 1,
+   Stop = 2,
+   Reply = 6,
+   Resume = 7,
+   Suspend = 8,
+   Send = 9,
+ }

+ public class Windows.Foundation.Diagnostics.LoggingOptions {
+   public short Task { get; set; }
+   public int Tags { get; set; }
+   public Guid RelatedActivityId { get; set; }
+   public LoggingOpcode Opcode { get; set; }
+   public long Keywords { get; set; }
+   public Guid ActivityId { get; set; }
+   public LoggingOptions( long keywords );
+   public LoggingOptions();
+ }

| public class Windows.Foundation.Metadata.ActivatableAttribute : System.Attribute {
+   public ActivatableAttribute( uint version, Type type );
+   public ActivatableAttribute( Type type, uint version, Type contractName );
| }

+ public class Windows.Foundation.Metadata.AllowForWebAttribute : System.Attribute {
+   public AllowForWebAttribute();
+ }

+ public class Windows.Foundation.Metadata.ApiInformation {
+   public static bool IsTypePresent( string value );
+   public static bool IsMethodPresent( string value, string typeName );
+   public static bool IsMethodPresent( string value, string typeName, uint methodName );
+   public static bool IsEventPresent( string value, string typeName );
+   public static bool IsPropertyPresent( string value, string typeName );
+   public static bool IsReadOnlyPropertyPresent( string value, string typeName );
+   public static bool IsWriteablePropertyPresent( string value, string typeName );
+   public static bool IsEnumNamedValuePresent( string value, string enumTypeName );
+   public static bool IsApiContractPresent( string value, ushort contractName );
+   public static bool IsApiContractPresent( string value, ushort contractName, ushort majorVersion );
+ }

| public enum Windows.Foundation.Metadata.AttributeTargets {
+   ApiContract = 8192,
| }

| public class Windows.Foundation.Metadata.ComposableAttribute : System.Attribute {
+   public ComposableAttribute( Type type, CompositionType compositionType, uint version, Type contract );
| }

| public class Windows.Foundation.Metadata.DeprecatedAttribute : System.Attribute {
+   public DeprecatedAttribute( string message, DeprecationType type, uint version, Type contract );
| }

+ public class Windows.Foundation.Metadata.ExperimentalAttribute : System.Attribute {
+   public ExperimentalAttribute();
+ }

+ public class Windows.Foundation.Metadata.RemoteAsyncAttribute : System.Attribute {
+   public RemoteAsyncAttribute();
+ }

| public class Windows.Foundation.Metadata.StaticAttribute : System.Attribute {
+   public StaticAttribute( Type type, uint version, Type contractName );
| }

| public class Windows.Globalization.CalendarIdentifiers {
+   public string Persian { get; }
| }

| public class Windows.Globalization.NumeralSystemIdentifiers {
+   public string Brah { get; }
+   public string MathBold { get; }
+   public string MathDbl { get; }
+   public string MathMono { get; }
+   public string MathSanb { get; }
+   public string MathSans { get; }
+   public string ZmthBold { get; }
+   public string ZmthDbl { get; }
+   public string ZmthMono { get; }
+   public string ZmthSanb { get; }
+   public string ZmthSans { get; }
+   public string Osma { get; }
| }

+ public enum Windows.Graphics.DirectX.DirectXPixelFormat {
+   Unknown = 0,
+   R32G32B32A32Typeless = 1,
+   R32G32B32A32Float = 2,
+   R32G32B32A32UInt = 3,
+   R32G32B32A32Int = 4,
+   R32G32B32Typeless = 5,
+   R32G32B32Float = 6,
+   R32G32B32UInt = 7,
+   R32G32B32Int = 8,
+   R16G16B16A16Typeless = 9,
+   R16G16B16A16Float = 10,
+   R16G16B16A16UIntNormalized = 11,
+   R16G16B16A16UInt = 12,
+   R16G16B16A16IntNormalized = 13,
+   R16G16B16A16Int = 14,
+   R32G32Typeless = 15,
+   R32G32Float = 16,
+   R32G32UInt = 17,
+   R32G32Int = 18,
+   R32G8X24Typeless = 19,
+   D32FloatS8X24UInt = 20,
+   R32FloatX8X24Typeless = 21,
+   X32TypelessG8X24UInt = 22,
+   R10G10B10A2Typeless = 23,
+   R10G10B10A2UIntNormalized = 24,
+   R10G10B10A2UInt = 25,
+   R11G11B10Float = 26,
+   R8G8B8A8Typeless = 27,
+   R8G8B8A8UIntNormalized = 28,
+   R8G8B8A8UIntNormalizedSrgb = 29,
+   R8G8B8A8UInt = 30,
+   R8G8B8A8IntNormalized = 31,
+   R8G8B8A8Int = 32,
+   R16G16Typeless = 33,
+   R16G16Float = 34,
+   R16G16UIntNormalized = 35,
+   R16G16UInt = 36,
+   R16G16IntNormalized = 37,
+   R16G16Int = 38,
+   R32Typeless = 39,
+   D32Float = 40,
+   R32Float = 41,
+   R32UInt = 42,
+   R32Int = 43,
+   R24G8Typeless = 44,
+   D24UIntNormalizedS8UInt = 45,
+   R24UIntNormalizedX8Typeless = 46,
+   X24TypelessG8UInt = 47,
+   R8G8Typeless = 48,
+   R8G8UIntNormalized = 49,
+   R8G8UInt = 50,
+   R8G8IntNormalized = 51,
+   R8G8Int = 52,
+   R16Typeless = 53,
+   R16Float = 54,
+   D16UIntNormalized = 55,
+   R16UIntNormalized = 56,
+   R16UInt = 57,
+   R16IntNormalized = 58,
+   R16Int = 59,
+   R8Typeless = 60,
+   R8UIntNormalized = 61,
+   R8UInt = 62,
+   R8IntNormalized = 63,
+   R8Int = 64,
+   A8UIntNormalized = 65,
+   R1UIntNormalized = 66,
+   R9G9B9E5SharedExponent = 67,
+   R8G8B8G8UIntNormalized = 68,
+   G8R8G8B8UIntNormalized = 69,
+   BC1Typeless = 70,
+   BC1UIntNormalized = 71,
+   BC1UIntNormalizedSrgb = 72,
+   BC2Typeless = 73,
+   BC2UIntNormalized = 74,
+   BC2UIntNormalizedSrgb = 75,
+   BC3Typeless = 76,
+   BC3UIntNormalized = 77,
+   BC3UIntNormalizedSrgb = 78,
+   BC4Typeless = 79,
+   BC4UIntNormalized = 80,
+   BC4IntNormalized = 81,
+   BC5Typeless = 82,
+   BC5UIntNormalized = 83,
+   BC5IntNormalized = 84,
+   B5G6R5UIntNormalized = 85,
+   B5G5R5A1UIntNormalized = 86,
+   B8G8R8A8UIntNormalized = 87,
+   B8G8R8X8UIntNormalized = 88,
+   R10G10B10XRBiasA2UIntNormalized = 89,
+   B8G8R8A8Typeless = 90,
+   B8G8R8A8UIntNormalizedSrgb = 91,
+   B8G8R8X8Typeless = 92,
+   B8G8R8X8UIntNormalizedSrgb = 93,
+   BC6HTypeless = 94,
+   BC6H16UnsignedFloat = 95,
+   BC6H16Float = 96,
+   BC7Typeless = 97,
+   BC7UIntNormalized = 98,
+   BC7UIntNormalizedSrgb = 99,
+   Ayuv = 100,
+   Y410 = 101,
+   Y416 = 102,
+   NV12 = 103,
+   P010 = 104,
+   P016 = 105,
+   Opaque420 = 106,
+   Yuy2 = 107,
+   Y210 = 108,
+   Y216 = 109,
+   NV11 = 110,
+   AI44 = 111,
+   IA44 = 112,
+   P8 = 113,
+   A8P8 = 114,
+   B4G4R4A4UIntNormalized = 115,
+   P208 = 130,
+   V208 = 131,
+   V408 = 132,
+   Astc4x4Typeless = 133,
+   Astc4x4Normalized = 134,
+   Astc4x4NormalizedSrgb = 135,
+   Astc5x4Typeless = 137,
+   Astc5x4Normalized = 138,
+   Astc5x4NormalizedSrgb = 139,
+   Astc5x5Typeless = 141,
+   Astc5x5Normalized = 142,
+   Astc5x5NormalizedSrgb = 143,
+   Astc6x5Typeless = 145,
+   Astc6x5Normalized = 146,
+   Astc6x5NormalizedSrgb = 147,
+   Astc6x6Typeless = 149,
+   Astc6x6Normalized = 150,
+   Astc6x6NormalizedSrgb = 151,
+   Astc8x5Typeless = 153,
+   Astc8x5Normalized = 154,
+   Astc8x5NormalizedSrgb = 155,
+   Astc8x6Typeless = 157,
+   Astc8x6Normalized = 158,
+   Astc8x6NormalizedSrgb = 159,
+   Astc8x8Typeless = 161,
+   Astc8x8Normalized = 162,
+   Astc8x8NormalizedSrgb = 163,
+   Astc10x5Typeless = 165,
+   Astc10x5Normalized = 166,
+   Astc10x5NormalizedSrgb = 167,
+   Astc10x6Typeless = 169,
+   Astc10x6Normalized = 170,
+   Astc10x6NormalizedSrgb = 171,
+   Astc10x8Typeless = 173,
+   Astc10x8Normalized = 174,
+   Astc10x8NormalizedSrgb = 175,
+   Astc10x10Typeless = 177,
+   Astc10x10Normalized = 178,
+   Astc10x10NormalizedSrgb = 179,
+   Astc12x10Typeless = 181,
+   Astc12x10Normalized = 182,
+   Astc12x10NormalizedSrgb = 183,
+   Astc12x12Typeless = 185,
+   Astc12x12Normalized = 186,
+   Astc12x12NormalizedSrgb = 187,
+ }

+ public enum Windows.Graphics.DirectX.Direct3D11.Direct3DBindings {
+   VertexBuffer = 1,
+   IndexBuffer = 2,
+   ConstantBuffer = 4,
+   ShaderResource = 8,
+   StreamOutput = 16,
+   RenderTarget = 32,
+   DepthStencil = 64,
+   UnorderedAccess = 128,
+   Decoder = 512,
+   VideoEncoder = 1024,
+ }

+ public struct Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription {
+   public int Count;
+   public int Quality;
+ }

+ public struct Windows.Graphics.DirectX.Direct3D11.Direct3DSurfaceDescription {
+   public int Width;
+   public int Height;
+   public DirectXPixelFormat Format;
+   public Direct3DMultisampleDescription MultisampleDescription;
+ }

+ public enum Windows.Graphics.DirectX.Direct3D11.Direct3DUsage {
+   Default = 0,
+   Immutable = 1,
+   Dynamic = 2,
+   Staging = 3,
+ }

+ public interface Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice {
+   public void Trim();
+ }

+ public interface Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface {
+   public Direct3DSurfaceDescription Description { get; }
+ }

+ public class Windows.Graphics.Imaging.BitmapBuffer {
+   public uint Length { get; set; }
+   public uint Capacity { get; }
+   public int GetPlaneCount();
+   public BitmapPlaneDescription GetPlaneDescription( int value );
+   public void Close();
+ }

+ public enum Windows.Graphics.Imaging.BitmapBufferAccessMode {
+   Read = 0,
+   ReadWrite = 1,
+   Write = 2,
+ }

| public class Windows.Graphics.Imaging.BitmapDecoder {
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync();
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat );
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat, BitmapTransform alphaMode, ExifOrientationMode transform, ColorManagementMode exifOrientationMode );
| }

| public class Windows.Graphics.Imaging.BitmapEncoder {
+   public void SetSoftwareBitmap( SoftwareBitmap bitmap );
| }

| public class Windows.Graphics.Imaging.BitmapFrame {
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync();
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat );
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat, BitmapTransform alphaMode, ExifOrientationMode transform, ColorManagementMode exifOrientationMode );
| }

| public enum Windows.Graphics.Imaging.BitmapPixelFormat {
+   Gray16 = 57,
+   Gray8 = 62,
+   Nv12 = 103,
+   Yuy2 = 107,
| }

+ public struct Windows.Graphics.Imaging.BitmapPlaneDescription {
+   public int StartIndex;
+   public int Width;
+   public int Height;
+   public int Stride;
+ }

+ public interface Windows.Graphics.Imaging.IBitmapFrameWithSoftwareBitmap {
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync();
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat );
+   public IAsyncOperation<SoftwareBitmap> GetSoftwareBitmapAsync( BitmapPixelFormat value, BitmapAlphaMode pixelFormat, BitmapTransform alphaMode, ExifOrientationMode transform, ColorManagementMode exifOrientationMode );
+ }

+ public class Windows.Graphics.Imaging.SoftwareBitmap {
+   public double DpiY { get; set; }
+   public double DpiX { get; set; }
+   public BitmapAlphaMode BitmapAlphaMode { get; }
+   public BitmapPixelFormat BitmapPixelFormat { get; }
+   public bool IsReadOnly { get; }
+   public int PixelHeight { get; }
+   public int PixelWidth { get; }
+   public SoftwareBitmap( BitmapPixelFormat format, int width, int height );
+   public SoftwareBitmap( BitmapPixelFormat format, int width, int height, BitmapAlphaMode alpha );
+   public BitmapBuffer LockBuffer( BitmapBufferAccessMode value );
+   public void CopyTo( SoftwareBitmap bitmap );
+   public void CopyFromBuffer( IBuffer buffer );
+   public void CopyToBuffer( IBuffer buffer );
+   public SoftwareBitmap GetReadOnlyView();
+   public void Close();
+   public static SoftwareBitmap Copy( SoftwareBitmap value );
+   public static SoftwareBitmap Convert( SoftwareBitmap value, BitmapPixelFormat source );
+   public static SoftwareBitmap Convert( SoftwareBitmap value, BitmapPixelFormat source, BitmapAlphaMode format );
+   public static SoftwareBitmap CreateCopyFromBuffer( IBuffer value, BitmapPixelFormat source, int format, int width );
+   public static SoftwareBitmap CreateCopyFromBuffer( IBuffer value, BitmapPixelFormat source, int format, int width, BitmapAlphaMode height );
+   public static IAsyncOperation<SoftwareBitmap> CreateCopyFromSurfaceAsync( IDirect3DSurface value );
+   public static IAsyncOperation<SoftwareBitmap> CreateCopyFromSurfaceAsync( IDirect3DSurface value, BitmapAlphaMode surface );
+ }

+ public interface Windows.Graphics.Printing.IPrintDocumentSource {
+ }

+ public interface Windows.Graphics.Printing.IPrintTaskOptionsCore {
+   public PrintPageDescription GetPageDescription( uint description );
+ }

+ public interface Windows.Graphics.Printing.IPrintTaskOptionsCoreProperties {
+   public PrintBinding Binding { get; set; }
+   public PrintCollation Collation { get; set; }
+   public PrintColorMode ColorMode { get; set; }
+   public PrintDuplex Duplex { get; set; }
+   public PrintHolePunch HolePunch { get; set; }
+   public uint MaxCopies { get; }
+   public PrintMediaSize MediaSize { get; set; }
+   public PrintMediaType MediaType { get; set; }
+   public uint MinCopies { get; }
+   public uint NumberOfCopies { get; set; }
+   public PrintOrientation Orientation { get; set; }
+   public PrintQuality PrintQuality { get; set; }
+   public PrintStaple Staple { get; set; }
+ }

+ public interface Windows.Graphics.Printing.IPrintTaskOptionsCoreUIConfiguration {
+   public IVector<string> DisplayedOptions { get; }
+ }

+ public enum Windows.Graphics.Printing.PrintBinding {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   None = 3,
+   Bale = 4,
+   BindBottom = 5,
+   BindLeft = 6,
+   BindRight = 7,
+   BindTop = 8,
+   Booklet = 9,
+   EdgeStitchBottom = 10,
+   EdgeStitchLeft = 11,
+   EdgeStitchRight = 12,
+   EdgeStitchTop = 13,
+   Fold = 14,
+   JogOffset = 15,
+   Trim = 16,
+ }

+ public enum Windows.Graphics.Printing.PrintCollation {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   Collated = 3,
+   Uncollated = 4,
+ }

+ public enum Windows.Graphics.Printing.PrintColorMode {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   Color = 3,
+   Grayscale = 4,
+   Monochrome = 5,
+ }

+ public enum Windows.Graphics.Printing.PrintDuplex {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   OneSided = 3,
+   TwoSidedShortEdge = 4,
+   TwoSidedLongEdge = 5,
+ }

+ public enum Windows.Graphics.Printing.PrintHolePunch {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   None = 3,
+   LeftEdge = 4,
+   RightEdge = 5,
+   TopEdge = 6,
+   BottomEdge = 7,
+ }

+ public class Windows.Graphics.Printing.PrintManager {
+   public static PrintManager GetForCurrentView();
+   public static IAsyncOperation<bool> ShowPrintUIAsync();
+   TypedEventHandler<PrintManager, PrintTaskRequestedEventArgs> PrintTaskRequested;
+ }

+ public enum Windows.Graphics.Printing.PrintMediaSize {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   BusinessCard = 3,
+   CreditCard = 4,
+   IsoA0 = 5,
+   IsoA1 = 6,
+   IsoA10 = 7,
+   IsoA2 = 8,
+   IsoA3 = 9,
+   IsoA3Extra = 10,
+   IsoA3Rotated = 11,
+   IsoA4 = 12,
+   IsoA4Extra = 13,
+   IsoA4Rotated = 14,
+   IsoA5 = 15,
+   IsoA5Extra = 16,
+   IsoA5Rotated = 17,
+   IsoA6 = 18,
+   IsoA6Rotated = 19,
+   IsoA7 = 20,
+   IsoA8 = 21,
+   IsoA9 = 22,
+   IsoB0 = 23,
+   IsoB1 = 24,
+   IsoB10 = 25,
+   IsoB2 = 26,
+   IsoB3 = 27,
+   IsoB4 = 28,
+   IsoB4Envelope = 29,
+   IsoB5Envelope = 30,
+   IsoB5Extra = 31,
+   IsoB7 = 32,
+   IsoB8 = 33,
+   IsoB9 = 34,
+   IsoC0 = 35,
+   IsoC1 = 36,
+   IsoC10 = 37,
+   IsoC2 = 38,
+   IsoC3 = 39,
+   IsoC3Envelope = 40,
+   IsoC4 = 41,
+   IsoC4Envelope = 42,
+   IsoC5 = 43,
+   IsoC5Envelope = 44,
+   IsoC6 = 45,
+   IsoC6C5Envelope = 46,
+   IsoC6Envelope = 47,
+   IsoC7 = 48,
+   IsoC8 = 49,
+   IsoC9 = 50,
+   IsoDLEnvelope = 51,
+   IsoDLEnvelopeRotated = 52,
+   IsoSRA3 = 53,
+   Japan2LPhoto = 54,
+   JapanChou3Envelope = 55,
+   JapanChou3EnvelopeRotated = 56,
+   JapanChou4Envelope = 57,
+   JapanChou4EnvelopeRotated = 58,
+   JapanDoubleHagakiPostcard = 59,
+   JapanDoubleHagakiPostcardRotated = 60,
+   JapanHagakiPostcard = 61,
+   JapanHagakiPostcardRotated = 62,
+   JapanKaku2Envelope = 63,
+   JapanKaku2EnvelopeRotated = 64,
+   JapanKaku3Envelope = 65,
+   JapanKaku3EnvelopeRotated = 66,
+   JapanLPhoto = 67,
+   JapanQuadrupleHagakiPostcard = 68,
+   JapanYou1Envelope = 69,
+   JapanYou2Envelope = 70,
+   JapanYou3Envelope = 71,
+   JapanYou4Envelope = 72,
+   JapanYou4EnvelopeRotated = 73,
+   JapanYou6Envelope = 74,
+   JapanYou6EnvelopeRotated = 75,
+   JisB0 = 76,
+   JisB1 = 77,
+   JisB10 = 78,
+   JisB2 = 79,
+   JisB3 = 80,
+   JisB4 = 81,
+   JisB4Rotated = 82,
+   JisB5 = 83,
+   JisB5Rotated = 84,
+   JisB6 = 85,
+   JisB6Rotated = 86,
+   JisB7 = 87,
+   JisB8 = 88,
+   JisB9 = 89,
+   NorthAmerica10x11 = 90,
+   NorthAmerica10x12 = 91,
+   NorthAmerica10x14 = 92,
+   NorthAmerica11x17 = 93,
+   NorthAmerica14x17 = 94,
+   NorthAmerica4x6 = 95,
+   NorthAmerica4x8 = 96,
+   NorthAmerica5x7 = 97,
+   NorthAmerica8x10 = 98,
+   NorthAmerica9x11 = 99,
+   NorthAmericaArchitectureASheet = 100,
+   NorthAmericaArchitectureBSheet = 101,
+   NorthAmericaArchitectureCSheet = 102,
+   NorthAmericaArchitectureDSheet = 103,
+   NorthAmericaArchitectureESheet = 104,
+   NorthAmericaCSheet = 105,
+   NorthAmericaDSheet = 106,
+   NorthAmericaESheet = 107,
+   NorthAmericaExecutive = 108,
+   NorthAmericaGermanLegalFanfold = 109,
+   NorthAmericaGermanStandardFanfold = 110,
+   NorthAmericaLegal = 111,
+   NorthAmericaLegalExtra = 112,
+   NorthAmericaLetter = 113,
+   NorthAmericaLetterExtra = 114,
+   NorthAmericaLetterPlus = 115,
+   NorthAmericaLetterRotated = 116,
+   NorthAmericaMonarchEnvelope = 117,
+   NorthAmericaNote = 118,
+   NorthAmericaNumber10Envelope = 119,
+   NorthAmericaNumber10EnvelopeRotated = 120,
+   NorthAmericaNumber11Envelope = 121,
+   NorthAmericaNumber12Envelope = 122,
+   NorthAmericaNumber14Envelope = 123,
+   NorthAmericaNumber9Envelope = 124,
+   NorthAmericaPersonalEnvelope = 125,
+   NorthAmericaQuarto = 126,
+   NorthAmericaStatement = 127,
+   NorthAmericaSuperA = 128,
+   NorthAmericaSuperB = 129,
+   NorthAmericaTabloid = 130,
+   NorthAmericaTabloidExtra = 131,
+   OtherMetricA3Plus = 132,
+   OtherMetricA4Plus = 133,
+   OtherMetricFolio = 134,
+   OtherMetricInviteEnvelope = 135,
+   OtherMetricItalianEnvelope = 136,
+   Prc10Envelope = 137,
+   Prc10EnvelopeRotated = 138,
+   Prc16K = 139,
+   Prc16KRotated = 140,
+   Prc1Envelope = 141,
+   Prc1EnvelopeRotated = 142,
+   Prc2Envelope = 143,
+   Prc2EnvelopeRotated = 144,
+   Prc32K = 145,
+   Prc32KBig = 146,
+   Prc32KRotated = 147,
+   Prc3Envelope = 148,
+   Prc3EnvelopeRotated = 149,
+   Prc4Envelope = 150,
+   Prc4EnvelopeRotated = 151,
+   Prc5Envelope = 152,
+   Prc5EnvelopeRotated = 153,
+   Prc6Envelope = 154,
+   Prc6EnvelopeRotated = 155,
+   Prc7Envelope = 156,
+   Prc7EnvelopeRotated = 157,
+   Prc8Envelope = 158,
+   Prc8EnvelopeRotated = 159,
+   Prc9Envelope = 160,
+   Prc9EnvelopeRotated = 161,
+   Roll04Inch = 162,
+   Roll06Inch = 163,
+   Roll08Inch = 164,
+   Roll12Inch = 165,
+   Roll15Inch = 166,
+   Roll18Inch = 167,
+   Roll22Inch = 168,
+   Roll24Inch = 169,
+   Roll30Inch = 170,
+   Roll36Inch = 171,
+   Roll54Inch = 172,
+ }

+ public enum Windows.Graphics.Printing.PrintMediaType {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   AutoSelect = 3,
+   Archival = 4,
+   BackPrintFilm = 5,
+   Bond = 6,
+   CardStock = 7,
+   Continuous = 8,
+   EnvelopePlain = 9,
+   EnvelopeWindow = 10,
+   Fabric = 11,
+   HighResolution = 12,
+   Label = 13,
+   MultiLayerForm = 14,
+   MultiPartForm = 15,
+   Photographic = 16,
+   PhotographicFilm = 17,
+   PhotographicGlossy = 18,
+   PhotographicHighGloss = 19,
+   PhotographicMatte = 20,
+   PhotographicSatin = 21,
+   PhotographicSemiGloss = 22,
+   Plain = 23,
+   Screen = 24,
+   ScreenPaged = 25,
+   Stationery = 26,
+   TabStockFull = 27,
+   TabStockPreCut = 28,
+   Transparency = 29,
+   TShirtTransfer = 30,
+   None = 31,
+ }

+ public enum Windows.Graphics.Printing.PrintOrientation {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   Portrait = 3,
+   PortraitFlipped = 4,
+   Landscape = 5,
+   LandscapeFlipped = 6,
+ }

+ public struct Windows.Graphics.Printing.PrintPageDescription {
+   public Size PageSize;
+   public Rect ImageableRect;
+   public uint DpiX;
+   public uint DpiY;
+ }

+ public enum Windows.Graphics.Printing.PrintQuality {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   Automatic = 3,
+   Draft = 4,
+   Fax = 5,
+   High = 6,
+   Normal = 7,
+   Photographic = 8,
+   Text = 9,
+ }

+ public enum Windows.Graphics.Printing.PrintStaple {
+   Default = 0,
+   NotAvailable = 1,
+   PrinterCustom = 2,
+   None = 3,
+   StapleTopLeft = 4,
+   StapleTopRight = 5,
+   StapleBottomLeft = 6,
+   StapleBottomRight = 7,
+   StapleDualLeft = 8,
+   StapleDualRight = 9,
+   StapleDualTop = 10,
+   StapleDualBottom = 11,
+   SaddleStitch = 12,
+ }

+ public class Windows.Graphics.Printing.PrintTask {
+   public PrintTaskOptions Options { get; }
+   public DataPackagePropertySet Properties { get; }
+   public IPrintDocumentSource Source { get; }
+   public bool IsPrinterTargetEnabled { get; set; }
+   public bool Is3DManufacturingTargetEnabled { get; set; }
+   TypedEventHandler<PrintTask, PrintTaskCompletedEventArgs> Completed;
+   TypedEventHandler<PrintTask, object> Previewing;
+   TypedEventHandler<PrintTask, PrintTaskProgressingEventArgs> Progressing;
+   TypedEventHandler<PrintTask, object> Submitting;
+ }

+ public class Windows.Graphics.Printing.PrintTaskCompletedEventArgs {
+   public PrintTaskCompletion Completion { get; }
+ }

+ public enum Windows.Graphics.Printing.PrintTaskCompletion {
+   Abandoned = 0,
+   Canceled = 1,
+   Failed = 2,
+   Submitted = 3,
+ }

+ public class Windows.Graphics.Printing.PrintTaskOptions {
+   public PrintMediaSize MediaSize { get; set; }
+   public PrintHolePunch HolePunch { get; set; }
+   public PrintColorMode ColorMode { get; set; }
+   public PrintCollation Collation { get; set; }
+   public PrintBinding Binding { get; set; }
+   public PrintDuplex Duplex { get; set; }
+   public PrintStaple Staple { get; set; }
+   public PrintQuality PrintQuality { get; set; }
+   public PrintOrientation Orientation { get; set; }
+   public uint NumberOfCopies { get; set; }
+   public PrintMediaType MediaType { get; set; }
+   public uint MinCopies { get; }
+   public uint MaxCopies { get; }
+   public IVector<string> DisplayedOptions { get; }
+   public PrintPageDescription GetPageDescription( uint description );
+ }

+ public class Windows.Graphics.Printing.PrintTaskProgressingEventArgs {
+   public uint DocumentPageCount { get; }
+ }

+ public class Windows.Graphics.Printing.PrintTaskRequest {
+   public DateTime Deadline { get; }
+   public PrintTask CreatePrintTask( string task, PrintTaskSourceRequestedHandler title );
+   public PrintTaskRequestedDeferral GetDeferral();
+ }

+ public class Windows.Graphics.Printing.PrintTaskRequestedDeferral {
+   public void Complete();
+ }

+ public class Windows.Graphics.Printing.PrintTaskRequestedEventArgs {
+   public PrintTaskRequest Request { get; }
+ }

+ public class Windows.Graphics.Printing.PrintTaskSourceRequestedArgs {
+   public DateTime Deadline { get; }
+   public void SetSource( IPrintDocumentSource source );
+   public PrintTaskSourceRequestedDeferral GetDeferral();
+ }

+ public class Windows.Graphics.Printing.PrintTaskSourceRequestedDeferral {
+   public void Complete();
+ }

+ public void delegate Windows.Graphics.Printing.PrintTaskSourceRequestedHandler( PrintTaskSourceRequestedArgs args );

+ public class Windows.Graphics.Printing.StandardPrintTaskOptions {
+   public string Binding { get; }
+   public string Collation { get; }
+   public string ColorMode { get; }
+   public string Copies { get; }
+   public string Duplex { get; }
+   public string HolePunch { get; }
+   public string InputBin { get; }
+   public string MediaSize { get; }
+   public string MediaType { get; }
+   public string NUp { get; }
+   public string Orientation { get; }
+   public string PrintQuality { get; }
+   public string Staple { get; }
+ }

+ public interface Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails {
+   public string DisplayName { get; set; }
+ }

+ public interface Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails {
+   public IVectorView<object> Items { get; }
+ }

+ public interface Windows.Graphics.Printing.OptionDetails.IPrintNumberOptionDetails {
+   public uint MaxValue { get; }
+   public uint MinValue { get; }
+ }

+ public interface Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+   public string ErrorText { get; set; }
+   public string OptionId { get; }
+   public PrintOptionType OptionType { get; }
+   public PrintOptionStates State { get; set; }
+   public object Value { get; }
+   public bool TrySetValue( object succeeded );
+ }

+ public interface Windows.Graphics.Printing.OptionDetails.IPrintTextOptionDetails {
+   public uint MaxCharacters { get; }
+ }

+ public class Windows.Graphics.Printing.OptionDetails.PrintBindingOptionDetails {
+   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.Printing.OptionDetails.PrintCollationOptionDetails {
+   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.Printing.OptionDetails.PrintColorModeOptionDetails {
+   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.Printing.OptionDetails.PrintCopiesOptionDetails {
+   public uint MaxValue { get; }
+   public uint MinValue { 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.Printing.OptionDetails.PrintCustomItemDetails {
+   public string ItemDisplayName { get; set; }
+   public string ItemId { get; }
+ }

+ public class Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails {
+   public string DisplayName { get; set; }
+   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 void AddItem( string itemId, string displayName );
+ }

+ public class Windows.Graphics.Printing.OptionDetails.PrintCustomTextOptionDetails {
+   public string DisplayName { get; set; }
+   public uint MaxCharacters { get; set; }
+   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.Printing.OptionDetails.PrintDuplexOptionDetails {
+   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.Printing.OptionDetails.PrintHolePunchOptionDetails {
+   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.Printing.OptionDetails.PrintMediaSizeOptionDetails {
+   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.Printing.OptionDetails.PrintMediaTypeOptionDetails {
+   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 enum Windows.Graphics.Printing.OptionDetails.PrintOptionStates {
+   None = 0,
+   Enabled = 1,
+   Constrained = 2,
+ }

+ public enum Windows.Graphics.Printing.OptionDetails.PrintOptionType {
+   Unknown = 0,
+   Number = 1,
+   Text = 2,
+   ItemList = 3,
+ }

+ public class Windows.Graphics.Printing.OptionDetails.PrintOrientationOptionDetails {
+   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.Printing.OptionDetails.PrintQualityOptionDetails {
+   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.Printing.OptionDetails.PrintStapleOptionDetails {
+   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.Printing.OptionDetails.PrintTaskOptionChangedEventArgs {
+   public object OptionId { get; }
+ }

+ public class Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails {
+   public IVector<string> DisplayedOptions { get; }
+   public IMapView<string, IPrintOptionDetails> Options { get; }
+   public PrintCustomItemListOptionDetails CreateItemListOption( string itemListOption, string optionId );
+   public PrintCustomTextOptionDetails CreateTextOption( string textOption, string optionId );
+   public PrintPageDescription GetPageDescription( uint description );
+   public static PrintTaskOptionDetails GetFromPrintTaskOptions( PrintTaskOptions printTaskOptionDetails );
+   TypedEventHandler<PrintTaskOptionDetails, object> BeginValidation;
+   TypedEventHandler<PrintTaskOptionDetails, PrintTaskOptionChangedEventArgs> OptionChanged;
+ }

+ public enum Windows.Internal.LegacyLiveTile.LegacyLiveTileIntervalKind {
+   LegacyLiveTileIntervalKind_Hour = 0,
+   LegacyLiveTileIntervalKind_Day = 1,
+   LegacyLiveTileIntervalKind_Week = 2,
+   LegacyLiveTileIntervalKind_Month = 3,
+ }

+ public enum Windows.Internal.LegacyLiveTile.LegacyLiveTileRecurrenceType {
+   LegacyLiveTileRecurrenceType_Instant = 0,
+   LegacyLiveTileRecurrenceType_Onetime = 1,
+   LegacyLiveTileRecurrenceType_Interval = 2,
+ }

+ public class Windows.Internal.LegacyLiveTile.WinRTLegacyLiveTileJobManager {
+   public WinRTLegacyLiveTileJobManager();
+   public void AddLiveTileRequest( Guid productId, string TileID, LegacyLiveTileRecurrenceType Recurrence, bool userNoneIdle, byte[] pTileXml, byte[] pUrlXml );
+   public void AddLiveTileSchedule( Guid productId, string TileID, LegacyLiveTileRecurrenceType Recurrence, LegacyLiveTileIntervalKind Interval, uint maximumRunCount, bool runForever, DateTime startTime, byte[] pTileXml, byte[] pUrlXml );
+   public void RemoveLegacyLiveTileSubscription( Guid productId, string TileID, LegacyLiveTileRecurrenceType RecurrenceType );
+ }

+ public class Windows.Media.AudioBuffer {
+   public uint Length { get; set; }
+   public uint Capacity { get; }
+   public void Close();
+ }

+ public enum Windows.Media.AudioBufferAccessMode {
+   Read = 0,
+   ReadWrite = 1,
+   Write = 2,
+ }

+ public class Windows.Media.AudioFrame {
+   public IReference<TimeSpan> SystemRelativeTime { get; set; }
+   public IReference<TimeSpan> RelativeTime { get; set; }
+   public bool IsDiscontinuous { get; set; }
+   public IReference<TimeSpan> Duration { get; set; }
+   public IPropertySet ExtendedProperties { get; }
+   public bool IsReadOnly { get; }
+   public string Type { get; }
+   public AudioFrame( uint capacity );
+   public AudioBuffer LockBuffer( AudioBufferAccessMode value );
+   public void Close();
+ }

+ public interface Windows.Media.IMediaFrame {
+   public IReference<TimeSpan> Duration { get; set; }
+   public IPropertySet ExtendedProperties { get; }
+   public bool IsDiscontinuous { get; set; }
+   public bool IsReadOnly { get; }
+   public IReference<TimeSpan> RelativeTime { get; set; }
+   public IReference<TimeSpan> SystemRelativeTime { get; set; }
+   public string Type { get; }
+ }

+ public class Windows.Media.VideoFrame {
+   public IReference<TimeSpan> SystemRelativeTime { get; set; }
+   public IReference<TimeSpan> RelativeTime { get; set; }
+   public bool IsDiscontinuous { get; set; }
+   public IReference<TimeSpan> Duration { get; set; }
+   public IPropertySet ExtendedProperties { get; }
+   public bool IsReadOnly { get; }
+   public string Type { get; }
+   public IDirect3DSurface Direct3DSurface { get; }
+   public SoftwareBitmap SoftwareBitmap { get; }
+   public VideoFrame( BitmapPixelFormat format, int width, int height );
+   public VideoFrame( BitmapPixelFormat format, int width, int height, BitmapAlphaMode alpha );
+   public IAsyncAction CopyToAsync( VideoFrame value );
+   public void Close();
+ }

| public class Windows.Media.Capture.CapturedFrame {
+   public SoftwareBitmap SoftwareBitmap { get; }
| }

| public class Windows.Media.Capture.CapturedFrameControlValues {
+   public IReference<MediaCaptureFocusState> FocusState { get; }
+   public IReference<double> IsoAnalogGain { get; }
+   public IReference<double> IsoDigitalGain { get; }
+   public MediaRatio SensorFrameRate { get; }
+   public IReference<WhiteBalanceGain> WhiteBalanceGain { get; }
| }

| public class Windows.Media.Capture.LowLagMediaRecording {
+   public IAsyncAction PauseAsync( MediaCapturePauseBehavior operation );
+   public IAsyncAction ResumeAsync();
| }

| public class Windows.Media.Capture.MediaCapture {
+   public CameraStreamState CameraStreamState { get; }
+   public IAsyncOperation<IMediaExtension> AddAudioEffectAsync( IAudioEffectDefinition op );
+   public IAsyncOperation<IMediaExtension> AddVideoEffectAsync( IVideoEffectDefinition op, MediaStreamType definition );
+   public IAsyncAction PauseRecordAsync( MediaCapturePauseBehavior asyncInfo );
+   public IAsyncAction ResumeRecordAsync();
+   public IAsyncOperation<VideoFrame> GetPreviewFrameAsync();
+   public IAsyncOperation<VideoFrame> GetPreviewFrameAsync( VideoFrame operation );
| }

| public enum Windows.Media.Capture.MediaCategory {
+   Media = 2,
+   GameChat = 3,
+   Speech = 4,
| }

+ public struct Windows.Media.Capture.WhiteBalanceGain {
+   public double R;
+   public double G;
+   public double B;
+ }

| public class Windows.Media.Capture.Core.VariablePhotoSequenceCapture {
+   public IAsyncAction UpdateSettingsAsync();
| }

+ public class Windows.Media.Casting.CastingConnection {
+   public CastingSource Source { get; set; }
+   public CastingDevice Device { get; }
+   public CastingConnectionState State { get; }
+   public IAsyncOperation<CastingConnectionErrorStatus> DisconnectAsync();
+   public void Close();
+   TypedEventHandler<CastingConnection, CastingConnectionErrorOccurredEventArgs> ErrorOccurred;
+   TypedEventHandler<CastingConnection, object> StateChanged;
+ }

+ public class Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs {
+   public CastingConnectionErrorStatus ErrorStatus { get; }
+   public string Message { get; }
+ }

+ public enum Windows.Media.Casting.CastingConnectionErrorStatus {
+   Succeeded = 0,
+   DeviceDidNotRespond = 1,
+   DeviceError = 2,
+   DeviceLocked = 3,
+   ProtectedPlaybackFailed = 4,
+   InvalidCastingSource = 5,
+   Unknown = 6,
+ }

+ public enum Windows.Media.Casting.CastingConnectionState {
+   Disconnected = 0,
+   Connected = 1,
+   Rendering = 2,
+   Disconnecting = 3,
+   Connecting = 4,
+ }

+ public class Windows.Media.Casting.CastingDevice {
+   public string FriendlyName { get; }
+   public IRandomAccessStreamWithContentType Icon { get; }
+   public string Id { get; }
+   public CastingPlaybackTypes SupportedCastingPlaybackTypes { get; }
+   public IAsyncOperation<StartCastingResult> RequestStartCastingAsync( CastingSource operation );
+ }

+ public enum Windows.Media.Casting.CastingPlaybackTypes {
+   None = 0,
+   Audio = 1,
+   Video = 2,
+   Picture = 4,
+ }

+ public class Windows.Media.Casting.CastingSource {
+   public Uri PreferredSourceUri { get; set; }
+ }

+ public interface Windows.Media.Casting.ICastingConnection {
+   public CastingDevice Device { get; }
+   public CastingSource Source { get; set; }
+   public CastingConnectionState State { get; }
+   public IAsyncOperation<CastingConnectionErrorStatus> DisconnectAsync();
+   TypedEventHandler<CastingConnection, CastingConnectionErrorOccurredEventArgs> ErrorOccurred;
+   TypedEventHandler<CastingConnection, object> StateChanged;
+ }

+ public class Windows.Media.Casting.StartCastingResult {
+   public CastingConnection Connection { get; }
+   public CastingConnectionErrorStatus Status { get; }
+ }

+ public class Windows.Media.Core.DetectedFace {
+   public Rect Bounds { get; }
+   public double Certainty { get; }
+ }

+ public class Windows.Media.Core.FaceDetectedEventArgs {
+   public FaceDetectionEffectFrame ResultFrame { get; }
+ }

+ public class Windows.Media.Core.FaceDetectionEffect {
+   public uint MaxFacesToDetect { get; set; }
+   public bool Enabled { get; set; }
+   public TimeSpan DesiredDetectionPeriod { get; set; }
+   public uint MaxFacesSupported { get; }
+   public void SetProperties( IPropertySet configuration );
+   TypedEventHandler<FaceDetectionEffect, FaceDetectedEventArgs> FaceDetected;
+ }

+ public class Windows.Media.Core.FaceDetectionEffectDefinition {
+   public bool SynchronousDetectionEnabled { get; set; }
+   public FaceDetectionQualityMode QualityMode { get; set; }
+   public string ActivatableClassId { get; }
+   public IPropertySet Properties { get; }
+   public FaceDetectionEffectDefinition();
+ }

+ public class Windows.Media.Core.FaceDetectionEffectFrame {
+   public IVectorView<DetectedFace> Faces { get; }
+   public bool IsDelayed { get; }
+   public IReference<TimeSpan> SystemRelativeTime { get; set; }
+   public IReference<TimeSpan> RelativeTime { get; set; }
+   public bool IsDiscontinuous { get; set; }
+   public IReference<TimeSpan> Duration { get; set; }
+   public IPropertySet ExtendedProperties { get; }
+   public bool IsReadOnly { get; }
+   public string Type { get; }
+   public void Close();
+ }

+ public enum Windows.Media.Core.FaceDetectionQualityMode {
+   HighPerformance = 0,
+   Balanced = 1,
+   HighQuality = 2,
+ }

+ public class Windows.Media.Core.FlashTechniqueControl {
+   public bool FrameControllersEnabled { get; set; }
+   public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.FlashTechniqueOutput {
+   public double Certainty { get; }
+   public IVectorView<FrameController> FrameControllers { get; }
+ }

+ public class Windows.Media.Core.HazeControl {
+   public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.HazeOutput {
+   public double Certainty { get; }
+ }

+ public class Windows.Media.Core.HighDynamicRangeControl {
+   public bool FrameControllersEnabled { get; set; }
+   public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.HighDynamicRangeOutput {
+   public double Certainty { get; }
+   public IVectorView<FrameController> FrameControllers { get; }
+ }

+ public class Windows.Media.Core.LowLightControl {
+   public bool FrameControllersEnabled { get; set; }
+   public bool Enabled { get; set; }
+ }

+ public class Windows.Media.Core.LowLightOutput {
+   public double Certainty { get; }
+   public IVectorView<FrameController> FrameControllers { get; }
+ }

+ public class Windows.Media.Core.SceneAnalysisEffect {
+   public TimeSpan DesiredAnalysisPeriod { get; set; }
+   public FlashTechniqueControl FlashTechniqueAnalyzer { get; }
+   public HazeControl HazeAnalyzer { get; }
+   public HighDynamicRangeControl HighDynamicRangeAnalyzer { get; }
+   public LowLightControl LowLightAnalyzer { get; }
+   public void SetProperties( IPropertySet configuration );
+   TypedEventHandler<SceneAnalysisEffect, SceneAnalyzedEventArgs> SceneAnalyzed;
+ }

+ public class Windows.Media.Core.SceneAnalysisEffectDefinition {
+   public string ActivatableClassId { get; }
+   public IPropertySet Properties { get; }
+   public SceneAnalysisEffectDefinition();
+ }

+ public class Windows.Media.Core.SceneAnalysisEffectFrame {
+   public FlashTechniqueOutput FlashTechnique { get; }
+   public CapturedFrameControlValues FrameControlValues { get; }
+   public HazeOutput Haze { get; }
+   public HighDynamicRangeOutput HighDynamicRange { get; }
+   public LowLightOutput LowLight { get; }
+   public IReference<TimeSpan> SystemRelativeTime { get; set; }
+   public IReference<TimeSpan> RelativeTime { get; set; }
+   public bool IsDiscontinuous { get; set; }
+   public IReference<TimeSpan> Duration { get; set; }
+   public IPropertySet ExtendedProperties { get; }
+   public bool IsReadOnly { get; }
+   public string Type { get; }
+   public void Close();
+ }

+ public class Windows.Media.Core.SceneAnalyzedEventArgs {
+   public SceneAnalysisEffectFrame ResultFrame { get; }
+ }

+ public class Windows.Media.Core.VideoStabilizationEffect {
+   public bool Enabled { get; set; }
+   public IAsyncOperation<MediaEncodingProfile> ConfigureEncodingProfileAsync( VideoDeviceController asyncInfo, MediaEncodingProfile controller );
+   public void SetProperties( IPropertySet configuration );
+ }

+ public class Windows.Media.Core.VideoStabilizationEffectDefinition {
+   public VideoStabilizationQualityMode QualityMode { get; set; }
+   public bool LowLatencyEnabled { get; set; }
+   public string ActivatableClassId { get; }
+   public IPropertySet Properties { get; }
+   public VideoStabilizationEffectDefinition();
+ }

+ public enum Windows.Media.Core.VideoStabilizationQualityMode {
+   HighPerformance = 0,
+   Balanced = 1,
+   HighQuality = 2,
+ }

+ public enum Windows.Media.Devices.CameraStreamState {
+   NotStreaming = 0,
+   Streaming = 1,
+   BlockedForPrivacy = 2,
+   Shutdown = 3,
+ }

+ public class Windows.Media.Devices.ExposurePriorityVideoControl {
+   public bool Enabled { get; set; }
+   public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.HdrVideoControl {
+   public HdrVideoMode Mode { get; set; }
+   public bool Supported { get; }
+   public IVectorView<HdrVideoMode> SupportedModes { get; }
+ }

+ public enum Windows.Media.Devices.HdrVideoMode {
+   Off = 0,
+   On = 1,
+   Auto = 2,
+ }

+ public enum Windows.Media.Devices.MediaCaptureOptimization {
+   Default = 0,
+   Quality = 1,
+   Latency = 2,
+   Power = 3,
+   LatencyThenQuality = 4,
+   LatencyThenPower = 5,
+   PowerAndQuality = 6,
+ }

+ public enum Windows.Media.Devices.MediaCapturePauseBehavior {
+   RetainHardwareResources = 0,
+   ReleaseHardwareResources = 1,
+ }

+ public class Windows.Media.Devices.OpticalImageStabilizationControl {
+   public OpticalImageStabilizationMode Mode { get; set; }
+   public bool Supported { get; }
+   public IVectorView<OpticalImageStabilizationMode> SupportedModes { get; }
+ }

+ public enum Windows.Media.Devices.OpticalImageStabilizationMode {
+   Off = 0,
+   On = 1,
+   Auto = 2,
+ }

| public class Windows.Media.Devices.VideoDeviceController {
+   public MediaCaptureOptimization DesiredOptimization { get; set; }
+   public ExposurePriorityVideoControl ExposurePriorityVideoControl { get; }
+   public HdrVideoControl HdrVideoControl { get; }
+   public OpticalImageStabilizationControl OpticalImageStabilizationControl { get; }
| }

| public class Windows.Media.Devices.ZoomControl {
+   public ZoomTransitionMode Mode { get; }
+   public IVectorView<ZoomTransitionMode> SupportedModes { get; }
+   public void Configure( ZoomSettings settings );
| }

+ public class Windows.Media.Devices.ZoomSettings {
+   public float Value { get; set; }
+   public ZoomTransitionMode Mode { get; set; }
+   public ZoomSettings();
+ }

+ public enum Windows.Media.Devices.ZoomTransitionMode {
+   Auto = 0,
+   Direct = 1,
+   Smooth = 2,
+ }

| public class Windows.Media.Devices.Core.FrameControlCapabilities {
+   public FrameFlashCapabilities Flash { get; }
| }

| public class Windows.Media.Devices.Core.FrameController {
+   public FrameFlashControl FlashControl { get; }
| }

+ public class Windows.Media.Devices.Core.FrameFlashCapabilities {
+   public bool PowerSupported { get; }
+   public bool RedEyeReductionSupported { get; }
+   public bool Supported { get; }
+ }

+ public class Windows.Media.Devices.Core.FrameFlashControl {
+   public bool RedEyeReduction { get; set; }
+   public float PowerPercent { get; set; }
+   public FrameFlashMode Mode { get; set; }
+   public bool Auto { get; set; }
+ }

+ public enum Windows.Media.Devices.Core.FrameFlashMode {
+   Disable = 0,
+   Enable = 1,
+   Global = 2,
+ }

| public class Windows.Media.Editing.MediaClip {
+   public static MediaClip CreateFromSurface( IDirect3DSurface value, TimeSpan surface );
| }

| public class Windows.Media.Editing.MediaComposition {
+   public IVector<MediaOverlayLayer> OverlayLayers { get; }
| }

+ public class Windows.Media.Editing.MediaOverlay {
+   public Rect Position { get; set; }
+   public double Opacity { get; set; }
+   public TimeSpan Delay { get; set; }
+   public bool AudioEnabled { get; set; }
+   public MediaClip Clip { get; }
+   public MediaOverlay( MediaClip clip );
+   public MediaOverlay( MediaClip clip, Rect position, double opacity );
+   public MediaOverlay Clone();
+ }

+ public class Windows.Media.Editing.MediaOverlayLayer {
+   public IVideoCompositorDefinition CustomCompositorDefinition { get; }
+   public IVector<MediaOverlay> Overlays { get; }
+   public MediaOverlayLayer( IVideoCompositorDefinition compositorDefinition );
+   public MediaOverlayLayer();
+   public MediaOverlayLayer Clone();
+ }

+ public class Windows.Media.Effects.CompositeVideoFrameContext {
+   public VideoFrame BackgroundFrame { get; }
+   public VideoFrame OutputFrame { get; }
+   public IVectorView<IDirect3DSurface> SurfacesToOverlay { get; }
+   public MediaOverlay GetOverlayForSurface( IDirect3DSurface value );
+ }

+ public interface Windows.Media.Effects.IBasicAudioEffect {
+   public IVectorView<AudioEncodingProperties> SupportedEncodingProperties { get; }
+   public bool UseInputFrameForOutput { get; }
+   public void SetEncodingProperties( AudioEncodingProperties encodingProperties );
+   public void ProcessFrame( ProcessAudioFrameContext context );
+   public void Close( MediaEffectClosedReason reason );
+   public void DiscardQueuedFrames();
+ }

+ public interface Windows.Media.Effects.IBasicVideoEffect {
+   public bool IsReadOnly { get; }
+   public IVectorView<VideoEncodingProperties> SupportedEncodingProperties { get; }
+   public MediaMemoryTypes SupportedMemoryTypes { get; }
+   public bool TimeIndependent { get; }
+   public void SetEncodingProperties( VideoEncodingProperties encodingProperties, IDirect3DDevice device );
+   public void ProcessFrame( ProcessVideoFrameContext context );
+   public void Close( MediaEffectClosedReason reason );
+   public void DiscardQueuedFrames();
+ }

+ public interface Windows.Media.Effects.IVideoCompositor {
+   public bool TimeIndependent { get; }
+   public void SetEncodingProperties( VideoEncodingProperties backgroundProperties, IDirect3DDevice device );
+   public void CompositeFrame( CompositeVideoFrameContext context );
+   public void Close( MediaEffectClosedReason reason );
+   public void DiscardQueuedFrames();
+ }

+ public interface Windows.Media.Effects.IVideoCompositorDefinition {
+   public string ActivatableClassId { get; }
+   public IPropertySet Properties { get; }
+ }

+ public enum Windows.Media.Effects.MediaEffectClosedReason {
+   Done = 0,
+   UnknownError = 1,
+   UnsupportedEncodingFormat = 2,
+   EffectCurrentlyUnloaded = 3,
+ }

+ public enum Windows.Media.Effects.MediaMemoryTypes {
+   Gpu = 0,
+   Cpu = 1,
+   GpuAndCpu = 2,
+ }

+ public class Windows.Media.Effects.ProcessAudioFrameContext {
+   public AudioFrame InputFrame { get; }
+   public AudioFrame OutputFrame { get; }
+ }

+ public class Windows.Media.Effects.ProcessVideoFrameContext {
+   public VideoFrame InputFrame { get; }
+   public VideoFrame OutputFrame { get; }
+ }

+ public class Windows.Media.Effects.VideoCompositorDefinition {
+   public string ActivatableClassId { get; }
+   public IPropertySet Properties { get; }
+   public VideoCompositorDefinition( string activatableClassId );
+   public VideoCompositorDefinition( string activatableClassId, IPropertySet props );
+ }

+ public class Windows.Media.Effects.VideoTransformEffectDefinition {
+   public string ActivatableClassId { get; }
+   public IPropertySet Properties { get; }
+   public MediaRotation Rotation { get; set; }
+   public MediaVideoProcessingAlgorithm ProcessingAlgorithm { get; set; }
+   public Color PaddingColor { get; set; }
+   public Size OutputSize { get; set; }
+   public MediaMirroringOptions Mirror { get; set; }
+   public Rect CropRectangle { get; set; }
+   public VideoTransformEffectDefinition();
+ }

+ public enum Windows.Media.MediaProperties.MediaMirroringOptions {
+   None = 0,
+   Horizontal = 1,
+   Vertical = 2,
+ }

+ public enum Windows.Media.MediaProperties.MediaRotation {
+   None = 0,
+   Clockwise90Degrees = 1,
+   Clockwise180Degrees = 2,
+   Clockwise270Degrees = 3,
+ }

| public enum Windows.Media.PlayTo.PlayToConnectionError {
+   ProtectedPlaybackFailed = 4,
| }

+ public enum Windows.Media.Playback.FailedMediaStreamKind {
+   Unknown = 0,
+   Audio = 1,
+   Video = 2,
+ }

+ public class Windows.Media.Protection.MediaProtectionPMPServer {
+   public IPropertySet Properties { get; }
+   public MediaProtectionPMPServer( IPropertySet pProperties );
+ }

| public enum Windows.Media.Render.AudioRenderCategory {
+   Movie = 1,
+   Media = 2,
+   GameChat = 8,
+   Speech = 9,
| }

| public class Windows.Networking.BackgroundTransfer.BackgroundDownloader {
+   public BackgroundTransferCompletionGroup CompletionGroup { get; }
+   public BackgroundDownloader( BackgroundTransferCompletionGroup completionGroup );
| }

+ public class Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup {
+   public bool IsEnabled { get; }
+   public IBackgroundTrigger Trigger { get; }
+   public BackgroundTransferCompletionGroup();
+   public void Enable();
+ }

+ public class Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroupTriggerDetails {
+   public IVectorView<DownloadOperation> Downloads { get; }
+   public IVectorView<UploadOperation> Uploads { get; }
+ }

| public class Windows.Networking.BackgroundTransfer.BackgroundUploader {
+   public BackgroundTransferCompletionGroup CompletionGroup { get; }
+   public BackgroundUploader( BackgroundTransferCompletionGroup completionGroup );
| }

| public class Windows.Networking.Connectivity.ConnectionProfileFilter {
+   public IReference<bool> IsRoaming { get; set; }
+   public IReference<bool> IsOverDataLimit { get; set; }
+   public IReference<bool> IsBackgroundDataUsageRestricted { get; set; }
+   public IBuffer RawData { get; }
| }

| public class Windows.Networking.Sockets.DatagramSocket {
+   public IAsyncAction CancelIOAsync();
+   public void EnableTransferOwnership( Guid taskId );
+   public void EnableTransferOwnership( Guid taskId, SocketActivityConnectedStandbyAction connectedStandbyAction );
+   public void TransferOwnership( string socketId );
+   public void TransferOwnership( string socketId, SocketActivityContext data );
+   public void TransferOwnership( string socketId, SocketActivityContext data, TimeSpan keepAliveTime );
| }

| public class Windows.Networking.Sockets.DatagramSocketControl {
+   public bool MulticastOnly { get; set; }
| }

+ public enum Windows.Networking.Sockets.SocketActivityConnectedStandbyAction {
+   DoNotWake = 0,
+   Wake = 1,
+ }

+ public class Windows.Networking.Sockets.SocketActivityContext {
+   public IBuffer Data { get; }
+   public SocketActivityContext( IBuffer data );
+ }

+ public class Windows.Networking.Sockets.SocketActivityInformation {
+   public SocketActivityContext Context { get; }
+   public DatagramSocket DatagramSocket { get; }
+   public string Id { get; }
+   public SocketActivityKind SocketKind { get; }
+   public StreamSocket StreamSocket { get; }
+   public StreamSocketListener StreamSocketListener { get; }
+   public Guid TaskId { get; }
+   public IMapView<string, SocketActivityInformation> AllSockets { get; }
+ }

+ public enum Windows.Networking.Sockets.SocketActivityKind {
+   None = 0,
+   StreamSocketListener = 1,
+   DatagramSocket = 2,
+   StreamSocket = 3,
+ }

+ public class Windows.Networking.Sockets.SocketActivityTriggerDetails {
+   public SocketActivityTriggerReason Reason { get; }
+   public SocketActivityInformation SocketInformation { get; }
+ }

+ public enum Windows.Networking.Sockets.SocketActivityTriggerReason {
+   None = 0,
+   SocketActivity = 1,
+   ConnectionAccepted = 2,
+   KeepAliveTimerExpired = 3,
+   SocketClosed = 4,
+ }

| public class Windows.Networking.Sockets.StreamSocket {
+   public IAsyncAction CancelIOAsync();
+   public void EnableTransferOwnership( Guid taskId );
+   public void EnableTransferOwnership( Guid taskId, SocketActivityConnectedStandbyAction connectedStandbyAction );
+   public void TransferOwnership( string socketId );
+   public void TransferOwnership( string socketId, SocketActivityContext data );
+   public void TransferOwnership( string socketId, SocketActivityContext data, TimeSpan keepAliveTime );
| }

| public class Windows.Networking.Sockets.StreamSocketControl {
+   public bool SerializeConnectionAttempts { get; set; }
| }

| public class Windows.Networking.Sockets.StreamSocketListener {
+   public IAsyncAction CancelIOAsync();
+   public void EnableTransferOwnership( Guid taskId );
+   public void EnableTransferOwnership( Guid taskId, SocketActivityConnectedStandbyAction connectedStandbyAction );
+   public void TransferOwnership( string socketId );
+   public void TransferOwnership( string socketId, SocketActivityContext data );
| }

| public class Windows.Networking.Sockets.StreamSocketListenerControl {
+   public byte OutboundUnicastHopLimit { get; set; }
+   public uint OutboundBufferSizeInBytes { get; set; }
+   public bool NoDelay { get; set; }
+   public bool KeepAlive { get; set; }
| }

+ public interface Windows.Networking.Vpn.IVpnCredential {
+   public string AdditionalPin { get; }
+   public Certificate CertificateCredential { get; }
+   public PasswordCredential OldPasswordCredential { get; }
+   public PasswordCredential PasskeyCredential { get; }
+ }

+ public interface Windows.Networking.Vpn.IVpnCustomPromptElement {
+   public bool Compulsory { get; set; }
+   public string DisplayName { get; set; }
+   public bool Emphasized { get; set; }
+ }

+ public interface Windows.Networking.Vpn.IVpnDomainNameInfoFactory {
+   public VpnDomainNameInfo CreateVpnDomainNameInfo( string domainNameInfo, VpnDomainNameType name, IIterable<HostName> nameType, IIterable<HostName> dnsServerList );
+ }

+ public interface Windows.Networking.Vpn.IVpnProfile {
+   public bool AlwaysOn { get; set; }
+   public IVector<VpnAppId> AppTriggers { get; }
+   public IVector<VpnDomainNameInfo> DomainNameInfoList { get; }
+   public string ProfileName { get; set; }
+   public bool RememberCredentials { get; set; }
+   public IVector<VpnRoute> Routes { get; }
+   public IVector<VpnTrafficFilter> TrafficFilters { get; }
+ }

+ public class Windows.Networking.Vpn.VpnAppId {
+   public string Value { get; set; }
+   public VpnAppIdType Type { get; set; }
+   public VpnAppId( VpnAppIdType type, string value );
+ }

+ public enum Windows.Networking.Vpn.VpnAppIdType {
+   PackageFamilyName = 0,
+   FullyQualifiedBinaryName = 1,
+   FilePath = 2,
+ }

+ public enum Windows.Networking.Vpn.VpnAuthenticationMethod {
+   Mschapv2 = 0,
+   Eap = 1,
+   Certificate = 2,
+   PresharedKey = 3,
+ }

+ public class Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs {
+   public VpnChannelActivityEventType ActivityState { get; }
+ }

+ public enum Windows.Networking.Vpn.VpnChannelRequestCredentialsOptions {
+   None = 0,
+   Retrying = 1,
+   UseForSingleSignIn = 2,
+ }

+ public class Windows.Networking.Vpn.VpnCredential {
+   public string AdditionalPin { get; }
+   public Certificate CertificateCredential { get; }
+   public PasswordCredential OldPasswordCredential { get; }
+   public PasswordCredential PasskeyCredential { get; }
+ }

+ public class Windows.Networking.Vpn.VpnCustomPromptBooleanInput {
+   public bool InitialValue { get; set; }
+   public bool Value { get; }
+   public bool Emphasized { get; set; }
+   public string DisplayName { get; set; }
+   public bool Compulsory { get; set; }
+   public VpnCustomPromptBooleanInput();
+ }

+ public class Windows.Networking.Vpn.VpnCustomPromptOptionSelector {
+   public bool Emphasized { get; set; }
+   public string DisplayName { get; set; }
+   public bool Compulsory { get; set; }
+   public IVector<string> Options { get; }
+   public uint SelectedIndex { get; }
+   public VpnCustomPromptOptionSelector();
+ }

+ public class Windows.Networking.Vpn.VpnCustomPromptText {
+   public bool Emphasized { get; set; }
+   public string DisplayName { get; set; }
+   public bool Compulsory { get; set; }
+   public string Text { get; set; }
+   public VpnCustomPromptText();
+ }

+ public class Windows.Networking.Vpn.VpnCustomPromptTextInput {
+   public bool Emphasized { get; set; }
+   public string DisplayName { get; set; }
+   public bool Compulsory { get; set; }
+   public string PlaceholderText { get; set; }
+   public bool IsTextHidden { get; set; }
+   public string Text { get; }
+   public VpnCustomPromptTextInput();
+ }

+ public class Windows.Networking.Vpn.VpnDomainNameAssignment {
+   public Uri ProxyAutoConfigurationUri { get; set; }
+   public IVector<VpnDomainNameInfo> DomainNameList { get; }
+   public VpnDomainNameAssignment();
+ }

+ public class Windows.Networking.Vpn.VpnDomainNameInfo {
+   public VpnDomainNameType DomainNameType { get; set; }
+   public HostName DomainName { get; set; }
+   public IVector<HostName> DnsServers { get; }
+   public IVector<HostName> WebProxyServers { get; }
+   public VpnDomainNameInfo( string name, VpnDomainNameType nameType, IIterable<HostName> dnsServerList, IIterable<HostName> proxyServerList );
+ }

+ public enum Windows.Networking.Vpn.VpnDomainNameType {
+   Suffix = 0,
+   FullyQualified = 1,
+   Reserved = 65535,
+ }

+ public enum Windows.Networking.Vpn.VpnIPProtocol {
+   None = 0,
+   Tcp = 6,
+   Udp = 17,
+ }

+ public class Windows.Networking.Vpn.VpnManagementAgent {
+   public VpnManagementAgent();
+   public IAsyncOperation<VpnManagementErrorStatus> AddProfileFromXmlAsync( string operation );
+   public IAsyncOperation<VpnManagementErrorStatus> AddProfileFromObjectAsync( IVpnProfile operation );
+   public IAsyncOperation<VpnManagementErrorStatus> UpdateProfileFromXmlAsync( string operation );
+   public IAsyncOperation<VpnManagementErrorStatus> UpdateProfileFromObjectAsync( IVpnProfile operation );
+   public IAsyncOperation<IVectorView<IVpnProfile>> GetProfilesAsync();
+   public IAsyncOperation<VpnManagementErrorStatus> DeleteProfileAsync( IVpnProfile operation );
+   public IAsyncOperation<VpnManagementErrorStatus> ConnectProfileAsync( IVpnProfile operation );
+   public IAsyncOperation<VpnManagementErrorStatus> ConnectProfileWithPasswordCredentialAsync( IVpnProfile operation, PasswordCredential profile );
+   public IAsyncOperation<VpnManagementErrorStatus> DisconnectProfileAsync( IVpnProfile operation );
+ }

+ public enum Windows.Networking.Vpn.VpnManagementErrorStatus {
+   Ok = 0,
+   Other = 1,
+   InvalidXmlSyntax = 2,
+   ProfileNameTooLong = 3,
+   ProfileInvalidAppId = 4,
+   AccessDenied = 5,
+ }

+ public class Windows.Networking.Vpn.VpnNativeProfile {
+   public VpnAuthenticationMethod UserAuthenticationMethod { get; set; }
+   public VpnAuthenticationMethod TunnelAuthenticationMethod { get; set; }
+   public VpnRoutingPolicyType RoutingPolicyType { get; set; }
+   public VpnNativeProtocolType NativeProtocolType { get; set; }
+   public string EapConfiguration { get; set; }
+   public IVector<string> Servers { get; }
+   public bool AlwaysOn { get; set; }
+   public bool RememberCredentials { get; set; }
+   public string ProfileName { get; set; }
+   public IVector<VpnAppId> AppTriggers { get; }
+   public IVector<VpnDomainNameInfo> DomainNameInfoList { get; }
+   public IVector<VpnRoute> Routes { get; }
+   public IVector<VpnTrafficFilter> TrafficFilters { get; }
+   public VpnNativeProfile();
+ }

+ public enum Windows.Networking.Vpn.VpnNativeProtocolType {
+   Pptp = 0,
+   L2tp = 1,
+   IpsecIkev2 = 2,
+ }

+ public class Windows.Networking.Vpn.VpnPlugInProfile {
+   public string VpnPluginPackageFamilyName { get; set; }
+   public string CustomConfiguration { get; set; }
+   public IVector<Uri> ServerUris { get; }
+   public bool RememberCredentials { get; set; }
+   public string ProfileName { get; set; }
+   public bool AlwaysOn { get; set; }
+   public IVector<VpnAppId> AppTriggers { get; }
+   public IVector<VpnDomainNameInfo> DomainNameInfoList { get; }
+   public IVector<VpnRoute> Routes { get; }
+   public IVector<VpnTrafficFilter> TrafficFilters { get; }
+   public VpnPlugInProfile();
+ }

+ public class Windows.Networking.Vpn.VpnProfile {
+   public bool RememberCredentials { get; set; }
+   public string ProfileName { get; set; }
+   public bool AlwaysOn { get; set; }
+   public IVector<VpnAppId> AppTriggers { get; }
+   public IVector<VpnDomainNameInfo> DomainNameInfoList { get; }
+   public IVector<VpnRoute> Routes { get; }
+   public IVector<VpnTrafficFilter> TrafficFilters { get; }
+   public VpnProfile();
+ }

+ public enum Windows.Networking.Vpn.VpnRoutingPolicyType {
+   SplitRouting = 0,
+   ForceAllTrafficOverVpn = 1,
+ }

+ public class Windows.Networking.Vpn.VpnTrafficFilter {
+   public VpnRoutingPolicyType RoutingPolicyType { get; set; }
+   public VpnIPProtocol Protocol { get; set; }
+   public VpnAppId AppId { get; set; }
+   public IVector<string> AppClaims { get; }
+   public IVector<string> LocalAddressRanges { get; }
+   public IVector<string> LocalPortRanges { get; }
+   public IVector<string> RemoteAddressRanges { get; }
+   public IVector<string> RemotePortRanges { get; }
+   public VpnTrafficFilter( VpnAppId appId );
+ }

+ public class Windows.Networking.Vpn.VpnTrafficFilterAssignment {
+   public bool AllowOutbound { get; set; }
+   public bool AllowInbound { get; set; }
+   public IVector<VpnTrafficFilter> TrafficFilterList { get; }
+   public VpnTrafficFilterAssignment();
+ }

| public class Windows.Phone.Networking.Voip.VoipCallCoordinator {
+   public void ConfirmNonSeamlessUpgrade( Guid callUpgradeGuid );
+   public void CancelUpgrade( Guid callUpgradeGuid );
| }

+ public class Windows.Phone.Notification.Management.AccessoryManager {
+   public bool PhoneMute { get; set; }
+   public PhoneCallAudioEndpoint PhoneCallAudioEndpoint { get; set; }
+   public bool BatterySaverState { get; }
+   public bool DoNotDisturbEnabled { get; }
+   public bool DrivingModeEnabled { get; }
+   public PlaybackCapability MediaPlaybackCapabilities { get; }
+   public PlaybackStatus MediaPlaybackStatus { get; }
+   public IVectorView<PhoneLineDetails> PhoneLineDetails { get; }
+   public static string RegisterAccessoryApp();
+   public static IAccessoryNotificationTriggerDetails GetNextTriggerDetails();
+   public static void ProcessTriggerDetails( IAccessoryNotificationTriggerDetails pDetails );
+   public static PhoneLineDetails GetPhoneLineDetails( Guid ppdetails );
+   public static void AcceptPhoneCall( uint phoneCallId );
+   public static void AcceptPhoneCall( uint phoneCallId, PhoneCallAudioEndpoint endPoint );
+   public static void AcceptPhoneCallWithVideo( uint phoneCallId );
+   public static void AcceptPhoneCallWithVideo( uint phoneCallId, PhoneCallAudioEndpoint endPoint );
+   public static void RejectPhoneCall( uint phoneCallId );
+   public static void RejectPhoneCall( uint phoneCallId, uint textResponseID );
+   public static void MakePhoneCall( Guid phoneLine, string phoneNumber );
+   public static void MakePhoneCall( Guid phoneLine, string phoneNumber, PhoneCallAudioEndpoint endPoint );
+   public static void MakePhoneCallWithVideo( Guid phoneLine, string phoneNumber );
+   public static void MakePhoneCallWithVideo( Guid phoneLine, string phoneNumber, PhoneCallAudioEndpoint endPoint );
+   public static void SwapPhoneCalls( uint phoneCallIdToHold, uint phoneCallIdOnHold );
+   public static void HoldPhoneCall( uint phoneCallId, bool holdCall );
+   public static void EndPhoneCall( uint phoneCallId );
+   public static void SnoozeAlarm( Guid alarmId );
+   public static void SnoozeAlarm( Guid alarmId, TimeSpan timeSpan );
+   public static void DismissAlarm( Guid alarmId );
+   public static void SnoozeReminder( Guid reminderId );
+   public static void SnoozeReminder( Guid reminderId, TimeSpan timeSpan );
+   public static void DismissReminder( Guid reminderId );
+   public static MediaMetadata GetMediaMetadata();
+   public static void PerformMediaPlaybackCommand( PlaybackCommand command );
+   public static IMapView<string, AppNotificationInfo> GetApps();
+   public static void EnableNotificationsForApplication( string appId );
+   public static void DisableNotificationsForApplication( string appId );
+   public static bool IsNotificationEnabledForApplication( string enabled );
+   public static int GetEnabledAccessoryNotificationTypes();
+   public static void EnableAccessoryNotificationTypes( int accessoryNotificationTypes );
+   public static void DisableAllAccessoryNotificationTypes();
+   public static bool GetUserConsent();
+   public static IRandomAccessStreamReference GetAppIcon( string returnValue );
+ }

+ public enum Windows.Phone.Notification.Management.AccessoryNotificationType {
+   None = 0,
+   Phone = 1,
+   Email = 2,
+   Reminder = 4,
+   Alarm = 8,
+   Toast = 16,
+   AppUninstalled = 32,
+   Dnd = 64,
+   DrivingMode = 128,
+   BatterySaver = 256,
+   Media = 512,
+   CortanaTile = 1024,
+ }

+ public class Windows.Phone.Notification.Management.AlarmNotificationTriggerDetails {
+   public bool StartedProcessing { get; set; }
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public DateTime TimeCreated { get; }
+   public Guid AlarmId { get; }
+   public ReminderState ReminderState { get; }
+   public DateTime Timestamp { get; }
+   public string Title { get; }
+ }

+ public class Windows.Phone.Notification.Management.AppNotificationInfo {
+   public string Id { get; }
+   public string Name { get; }
+ }

+ public class Windows.Phone.Notification.Management.CortanaTileNotificationTriggerDetails {
+   public bool StartedProcessing { get; set; }
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public DateTime TimeCreated { get; }
+   public string Content { get; }
+   public string EmphasizedText { get; }
+   public string LargeContent1 { get; }
+   public string LargeContent2 { get; }
+   public string NonWrappedSmallContent1 { get; }
+   public string NonWrappedSmallContent2 { get; }
+   public string NonWrappedSmallContent3 { get; }
+   public string NonWrappedSmallContent4 { get; }
+   public string Source { get; }
+   public string TileId { get; }
+ }

+ public class Windows.Phone.Notification.Management.EmailNotificationTriggerDetails {
+   public bool StartedProcessing { get; set; }
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public DateTime TimeCreated { get; }
+   public string AccountName { get; }
+   public EmailMessage EmailMessage { get; }
+   public string ParentFolderName { get; }
+   public string SenderAddress { get; }
+   public string SenderName { get; }
+   public DateTime Timestamp { get; }
+ }

+ public interface Windows.Phone.Notification.Management.IAccessoryNotificationTriggerDetails {
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public bool StartedProcessing { get; set; }
+   public DateTime TimeCreated { get; }
+ }

+ public class Windows.Phone.Notification.Management.MediaControlsTriggerDetails {
+   public bool StartedProcessing { get; set; }
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public DateTime TimeCreated { get; }
+   public MediaMetadata MediaMetadata { get; }
+   public PlaybackStatus PlaybackStatus { get; }
+ }

+ public class Windows.Phone.Notification.Management.MediaMetadata {
+   public string Album { get; }
+   public string Artist { get; }
+   public TimeSpan Duration { get; }
+   public string Subtitle { get; }
+   public IRandomAccessStreamReference Thumbnail { get; }
+   public string Title { get; }
+   public uint Track { get; }
+ }

+ public enum Windows.Phone.Notification.Management.PhoneCallAudioEndpoint {
+   Default = 0,
+   Speaker = 1,
+   Handsfree = 2,
+ }

+ public class Windows.Phone.Notification.Management.PhoneCallDetails {
+   public PhoneCallDirection CallDirection { get; }
+   public uint CallId { get; }
+   public PhoneMediaType CallMediaType { get; }
+   public PhoneCallTransport CallTransport { get; }
+   public uint ConferenceCallId { get; }
+   public string ContactName { get; }
+   public DateTime EndTime { get; }
+   public Guid PhoneLine { get; }
+   public string PhoneNumber { get; }
+   public IVectorView<TextResponse> PresetTextResponses { get; }
+   public DateTime StartTime { get; }
+   public PhoneCallState State { get; }
+ }

+ public enum Windows.Phone.Notification.Management.PhoneCallDirection {
+   Incoming = 0,
+   Outgoing = 1,
+ }

+ public enum Windows.Phone.Notification.Management.PhoneCallState {
+   Unknown = 0,
+   Ringing = 1,
+   Talking = 2,
+   Held = 3,
+   Ended = 4,
+ }

+ public enum Windows.Phone.Notification.Management.PhoneCallTransport {
+   Cellular = 0,
+   Voip = 1,
+ }

+ public class Windows.Phone.Notification.Management.PhoneLineDetails {
+   public bool DefaultOutgoingLine { get; }
+   public string DisplayName { get; }
+   public Guid LineId { get; }
+   public string LineNumber { get; }
+   public PhoneLineRegistrationState RegistrationState { get; }
+   public uint VoicemailCount { get; }
+ }

+ public enum Windows.Phone.Notification.Management.PhoneLineRegistrationState {
+   Disconnected = 0,
+   Home = 1,
+   Roaming = 2,
+ }

+ public enum Windows.Phone.Notification.Management.PhoneMediaType {
+   AudioOnly = 0,
+   AudioVideo = 1,
+ }

+ public class Windows.Phone.Notification.Management.PhoneNotificationTriggerDetails {
+   public bool StartedProcessing { get; set; }
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public DateTime TimeCreated { get; }
+   public PhoneCallDetails CallDetails { get; }
+   public Guid PhoneLineChangedId { get; }
+   public PhoneNotificationType PhoneNotificationType { get; }
+ }

+ public enum Windows.Phone.Notification.Management.PhoneNotificationType {
+   NewCall = 0,
+   CallChanged = 1,
+   LineChanged = 2,
+   PhoneCallAudioEndpointChanged = 3,
+   PhoneMuteChanged = 4,
+ }

+ public enum Windows.Phone.Notification.Management.PlaybackCapability {
+   None = 0,
+   Play = 1,
+   Pause = 2,
+   Stop = 4,
+   Record = 8,
+   FastForward = 16,
+   Rewind = 32,
+   Next = 64,
+   Previous = 128,
+   ChannelUp = 256,
+   ChannelDown = 512,
+ }

+ public enum Windows.Phone.Notification.Management.PlaybackCommand {
+   Play = 0,
+   Pause = 1,
+   Stop = 2,
+   Record = 3,
+   FastForward = 4,
+   Rewind = 5,
+   Next = 6,
+   Previous = 7,
+   ChannelUp = 8,
+   ChannelDown = 9,
+ }

+ public enum Windows.Phone.Notification.Management.PlaybackStatus {
+   None = 0,
+   TrackChanged = 1,
+   Stopped = 2,
+   Playing = 3,
+   Paused = 4,
+ }

+ public class Windows.Phone.Notification.Management.ReminderNotificationTriggerDetails {
+   public bool StartedProcessing { get; set; }
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public DateTime TimeCreated { get; }
+   public Appointment Appointment { get; }
+   public string Description { get; }
+   public string Details { get; }
+   public Guid ReminderId { get; }
+   public ReminderState ReminderState { get; }
+   public DateTime Timestamp { get; }
+   public string Title { get; }
+ }

+ public enum Windows.Phone.Notification.Management.ReminderState {
+   Active = 0,
+   Snoozed = 1,
+   Dismissed = 2,
+ }

+ public class Windows.Phone.Notification.Management.TextResponse {
+   public string Content { get; }
+   public uint Id { get; }
+ }

+ public class Windows.Phone.Notification.Management.ToastNotificationTriggerDetails {
+   public bool StartedProcessing { get; set; }
+   public AccessoryNotificationType AccessoryNotificationType { get; }
+   public string AppDisplayName { get; }
+   public string AppId { get; }
+   public DateTime TimeCreated { get; }
+   public bool SuppressPopup { get; }
+   public string Text1 { get; }
+   public string Text2 { get; }
+   public string Text3 { get; }
+   public string Text4 { get; }
+ }

* public interface Windows.Phone.UI.Core.ICoreWindowKeyboardInput;

| public class Windows.Security.Authentication.OnlineId.OnlineIdAuthenticator {
+   public string ApplicationSid { get; set; }
+   public string AccountId { get; set; }
| }

+ public class Windows.Security.Authentication.Web.Core.WebAuthenticationCoreManager {
+   public static IAsyncOperation<WebTokenRequestResult> GetTokenSilentlyAsync( WebTokenRequest asyncInfo );
+   public static IAsyncOperation<WebTokenRequestResult> GetTokenSilentlyAsync( WebTokenRequest asyncInfo, WebAccount request );
+   public static IAsyncOperation<WebTokenRequestResult> GetTokenSilentlyWithHintsAsync( WebTokenRequest asyncInfo, IVectorView<WebAccount> request );
+   public static void RequestTokenAndContinue( WebTokenRequest request );
+   public static void RequestTokenAndContinue( WebTokenRequest request, PropertySet continuationData );
+   public static void RequestTokenAndContinue( WebTokenRequest request, PropertySet continuationData, WebAccount webAccount );
+   public static void RequestTokenWithHintsAndContinue( WebTokenRequest request, PropertySet continuationData, IVectorView<WebAccount> webAccounts );
+   public static IAsyncOperation<WebTokenRequestResult> RequestTokenAsync( WebTokenRequest asyncInfo );
+   public static IAsyncOperation<WebTokenRequestResult> RequestTokenAsync( WebTokenRequest asyncInfo, WebAccount request );
+   public static IAsyncOperation<WebTokenRequestResult> RequestTokenWithHintsAsync( WebTokenRequest asyncInfo, IVectorView<WebAccount> request );
+   public static IAsyncOperation<WebAccount> FindAccountAsync( WebAccountProvider asyncInfo, string provider );
+   public static IAsyncOperation<WebAccountProvider> FindAccountProviderAsync( string asyncInfo );
+   public static IAsyncOperation<WebAccountProvider> FindAccountProviderWithAuthorityAsync( string asyncInfo, string webAccountProviderId );
+ }

+ public class Windows.Security.Authentication.Web.Core.WebProviderError {
+   public uint ErrorCode { get; }
+   public string ErrorMessage { get; }
+   public WebProviderError( uint errorCode, string errorMessage );
+ }

+ public class Windows.Security.Authentication.Web.Core.WebTokenRequest {
+   public string ClientId { get; }
+   public WebTokenRequestPromptType PromptType { get; }
+   public IMap<string, string> Properties { get; }
+   public string Scope { get; }
+   public WebAccountProvider WebAccountProvider { get; }
+   public WebTokenRequest( WebAccountProvider provider, string scope, string clientId );
+   public WebTokenRequest( WebAccountProvider provider, string scope, string clientId, WebTokenRequestPromptType promptType );
+ }

+ public enum Windows.Security.Authentication.Web.Core.WebTokenRequestPromptType {
+   Default = 0,
+   ForceAuthentication = 1,
+ }

+ public class Windows.Security.Authentication.Web.Core.WebTokenRequestResult {
+   public IVectorView<WebTokenResponse> ResponseData { get; }
+   public WebProviderError ResponseError { get; }
+   public WebTokenRequestStatus ResponseStatus { get; }
+   public IAsyncAction InvalidateCacheAsync();
+ }

+ public enum Windows.Security.Authentication.Web.Core.WebTokenRequestStatus {
+   Success = 0,
+   UserCancel = 1,
+   AccountSwitch = 2,
+   UserInteractionRequired = 3,
+   AccountProviderNotAvailable = 4,
+   ProviderError = 5,
+ }

+ public class Windows.Security.Authentication.Web.Core.WebTokenResponse {
+   public IMap<string, string> Properties { get; }
+   public WebProviderError ProviderError { get; }
+   public string Token { get; }
+   public WebAccount WebAccount { get; }
+   public WebTokenResponse( string token );
+   public WebTokenResponse( string token, WebAccount webAccount );
+   public WebTokenResponse( string token, WebAccount webAccount, WebProviderError error );
+   public WebTokenResponse();
+ }

+ public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation {
+   public void ReportCompleted();
+   public void ReportError( WebProviderError value );
+ }

+ public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+   public WebAccountProviderOperationKind Kind { get; }
+ }

+ public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderSilentReportOperation {
+   public void ReportUserInteractionRequired();
+ }

+ public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenObjects {
+   public IWebAccountProviderOperation Operation { get; }
+ }

+ public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenOperation {
+   public DateTime CacheExpirationTime { get; set; }
+   public WebProviderTokenRequest ProviderRequest { get; }
+   public IVector<WebProviderTokenResponse> ProviderResponses { get; }
+ }

+ public interface Windows.Security.Authentication.Web.Provider.IWebAccountProviderUIReportOperation {
+   public void ReportUserCanceled();
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountClientView {
+   public string AccountPairwiseId { get; }
+   public Uri ApplicationCallbackUri { get; }
+   public WebAccountClientViewType Type { get; }
+   public WebAccountClientView( WebAccountClientViewType viewType, Uri applicationCallbackUri );
+   public WebAccountClientView( WebAccountClientViewType viewType, Uri applicationCallbackUri, string accountPairwiseId );
+ }

+ public enum Windows.Security.Authentication.Web.Provider.WebAccountClientViewType {
+   IdOnly = 0,
+   IdAndProperties = 1,
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountManager {
+   public static IAsyncAction UpdateWebAccountPropertiesAsync( WebAccount asyncInfo, string webAccount, IMapView<string, string> webAccountUserName );
+   public static IAsyncOperation<WebAccount> AddWebAccountAsync( string asyncInfo, string webAccountId, IMapView<string, string> webAccountUserName );
+   public static IAsyncAction DeleteWebAccountAsync( WebAccount asyncInfo );
+   public static IAsyncOperation<IVectorView<WebAccount>> FindAllProviderWebAccountsAsync();
+   public static void SendTokenResultCompleted( IWebAccountProviderOperation pickerOperation );
+   public static void SendTokenResultCanceled( IWebAccountProviderOperation pickerOperation );
+   public static IAsyncAction PushCookiesAsync( Uri asyncInfo, IVectorView<HttpCookie> uri );
+   public static IAsyncAction SetViewAsync( WebAccount asyncInfo, WebAccountClientView webAccount );
+   public static IAsyncAction ClearViewAsync( WebAccount asyncInfo, Uri webAccount );
+   public static IAsyncOperation<IVectorView<WebAccountClientView>> GetViewsAsync( WebAccount asyncInfo );
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderAddAccountOperation {
+   public WebAccountProviderOperationKind Kind { get; }
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderDeleteAccountOperation {
+   public WebAccount WebAccount { get; }
+   public WebAccountProviderOperationKind Kind { get; }
+   public void ReportCompleted();
+   public void ReportError( WebProviderError value );
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderGetTokenSilentOperation {
+   public WebAccountProviderOperationKind Kind { get; }
+   public DateTime CacheExpirationTime { get; set; }
+   public WebProviderTokenRequest ProviderRequest { get; }
+   public IVector<WebProviderTokenResponse> ProviderResponses { get; }
+   public void ReportUserInteractionRequired();
+   public void ReportCompleted();
+   public void ReportError( WebProviderError value );
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderManageAccountOperation {
+   public WebAccount WebAccount { get; }
+   public WebAccountProviderOperationKind Kind { get; }
+ }

+ public enum Windows.Security.Authentication.Web.Provider.WebAccountProviderOperationKind {
+   RequestToken = 0,
+   GetTokenSilently = 1,
+   AddAccount = 2,
+   ManageAccount = 3,
+   DeleteAccount = 4,
+   RetrieveCookies = 5,
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderRequestTokenOperation {
+   public WebAccountProviderOperationKind Kind { get; }
+   public DateTime CacheExpirationTime { get; set; }
+   public WebProviderTokenRequest ProviderRequest { get; }
+   public IVector<WebProviderTokenResponse> ProviderResponses { get; }
+   public void ReportUserCanceled();
+   public void ReportCompleted();
+   public void ReportError( WebProviderError value );
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderRetrieveCookiesOperation {
+   public WebAccountProviderOperationKind Kind { get; }
+   public Uri Context { get; }
+   public IVector<HttpCookie> Cookies { get; }
+   public void ReportCompleted();
+   public void ReportError( WebProviderError value );
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebAccountProviderTriggerDetails {
+   public IWebAccountProviderOperation Operation { get; }
+ }

+ public enum Windows.Security.Authentication.Web.Provider.WebAccountSelectionOptions {
+   Default = 0,
+   AddNew = 1,
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebProviderTokenRequest {
+   public Uri ApplicationCallbackUri { get; }
+   public WebTokenRequest ClientRequest { get; }
+   public WebAccountSelectionOptions WebAccountSelectionOptions { get; }
+   public IVectorView<WebAccount> WebAccounts { get; }
+ }

+ public class Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse {
+   public WebTokenResponse ClientResponse { get; }
+   public WebProviderTokenResponse( WebTokenResponse webTokenResponse );
+ }

+ public interface Windows.Security.Credentials.IWebAccount {
+   public WebAccountState State { get; }
+   public string UserName { get; }
+   public WebAccountProvider WebAccountProvider { get; }
+ }

+ public class Windows.Security.Credentials.WebAccount {
+   public WebAccountState State { get; }
+   public string UserName { get; }
+   public WebAccountProvider WebAccountProvider { get; }
+   public string Id { get; }
+   public IMapView<string, string> Properties { get; }
+ }

+ public class Windows.Security.Credentials.WebAccountProvider {
+   public string DisplayName { get; }
+   public Uri IconUri { get; }
+   public string Id { get; }
+   public string Authority { get; }
+   public string DisplayPurpose { get; }
+   public IRandomAccessStreamReference Icon { get; }
+ }

+ public enum Windows.Security.Credentials.WebAccountState {
+   None = 0,
+   Connected = 1,
+   Error = 2,
+ }

| public class Windows.Security.Cryptography.Certificates.CertificateRequestProperties {
+   public byte[] CurveParameters { get; set; }
+   public string CurveName { get; set; }
| }

| public class Windows.Security.Cryptography.Certificates.KeyAlgorithmNames {
+   public string Ecdh { get; }
+   public string Ecdsa { get; }
| }

| public enum Windows.Security.Cryptography.Certificates.KeyProtectionLevel {
+   ConsentWithFingerprint = 3,
| }

| public class Windows.Security.Cryptography.Core.AsymmetricAlgorithmNames {
+   public string EcdsaSha256 { get; }
+   public string EcdsaSha384 { get; }
+   public string EcdsaSha512 { get; }
| }

| public class Windows.Security.Cryptography.Core.AsymmetricKeyAlgorithmProvider {
+   public CryptographicKey CreateKeyPairWithCurveName( string key );
+   public CryptographicKey CreateKeyPairWithCurveParameters( byte[] key );
| }

| public class Windows.Security.Cryptography.Core.CryptographicKey {
+   public string KeyName { get; }
+   public string UniqueId { get; }
| }

| public enum Windows.Security.Cryptography.Core.CryptographicPrivateKeyBlobType {
+   BCryptEccFullPrivateKey = 4,
| }

| public enum Windows.Security.Cryptography.Core.CryptographicPublicKeyBlobType {
+   BCryptEccFullPublicKey = 4,
| }

+ public class Windows.Security.Cryptography.Core.EccCurveNames {
+   public IVectorView<string> AllEccCurveNames { get; }
+   public string NistP256 { get; }
+   public string NistP384 { get; }
+   public string NistP521 { get; }
+   public string Secp256k1 { get; }
+   public string Secp256r1 { get; }
+   public string Secp384r1 { get; }
+   public string Secp521r1 { get; }
+   public string X962P192v1 { get; }
+   public string X962P192v2 { get; }
+   public string X962P192v3 { get; }
+   public string X962P192v4 { get; }
+   public string X962P239v1 { get; }
+   public string X962P239v2 { get; }
+   public string X962P239v3 { get; }
+   public string X962P256v1 { get; }
+ }

| public enum Windows.Services.Maps.MapLocationFinderStatus {
+   NotSupported = 6,
| }

| public enum Windows.Services.Maps.MapRouteFinderStatus {
+   NotSupported = 9,
| }

| public class Windows.Storage.ApplicationData {
+   public static IAsyncOperationWithProgress<ApplicationData, uint> ForUserAsync( User forUserOperation );
| }

+ public interface Windows.Storage.IStorageFile2 {
+   public IAsyncOperation<IRandomAccessStream> OpenAsync( FileAccessMode operation, StorageOpenOptions accessMode );
+   public IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync( StorageOpenOptions operation );
+ }

+ public interface Windows.Storage.IStorageFolder2 {
+   public IAsyncOperation<IStorageItem> TryGetItemAsync( string operation );
+ }

+ public interface Windows.Storage.IStorageItem2 {
+   public IAsyncOperation<StorageFolder> GetParentAsync();
+   public bool IsEqual( IStorageItem value );
+ }

| public class Windows.Storage.StorageFile {
+   public IAsyncOperation<StorageFolder> GetParentAsync();
+   public bool IsEqual( IStorageItem value );
+   public IAsyncOperation<IRandomAccessStream> OpenAsync( FileAccessMode operation, StorageOpenOptions accessMode );
+   public IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync( StorageOpenOptions operation );
| }

| public class Windows.Storage.StorageFolder {
+   public IAsyncOperation<StorageFolder> GetParentAsync();
+   public bool IsEqual( IStorageItem value );
+   public IAsyncOperation<IStorageItem> TryGetItemAsync( string operation );
| }

+ public enum Windows.Storage.StorageOpenOptions {
+   None = 0,
+   AllowOnlyReaders = 1,
+ }

+ public class Windows.Storage.FileProperties.GeotagHelper {
+   public static IAsyncOperation<Geopoint> GetGeotagAsync( IStorageFile operation );
+   public static IAsyncAction SetGeotagFromGeolocatorAsync( IStorageFile operation, Geolocator file );
+   public static IAsyncAction SetGeotagAsync( IStorageFile operation, Geopoint file );
+ }

+ public interface Windows.Storage.Streams.IClosableBuffer {
+   public uint Capacity { get; }
+   public uint Length { get; set; }
+ }

+ public enum Windows.System.BatteryStatus {
+   NotPresent = 0,
+   Discharging = 1,
+   Idle = 2,
+   Charging = 3,
+ }

+ public class Windows.System.FolderLauncherOptions {
+   public IVector<IStorageItem> ItemsToSelect { get; }
+   public ViewSizePreference DesiredRemainingView { get; set; }
+   public FolderLauncherOptions();
+ }

+ public interface Windows.System.ILauncherViewOptions {
+   public ViewSizePreference DesiredRemainingView { get; set; }
+ }

+ public interface Windows.System.IProtocolForResultsOperationPriv {
+   public void ReportCompletedPriv( IBuffer data );
+ }

+ public interface Windows.System.IValueSetProvider {
+   public IBuffer Buffer { get; }
+   public ValueSet ValueSet { get; }
+ }

+ public class Windows.System.KnownUserProperties {
+   public string AccountName { get; }
+   public string DisplayName { get; }
+   public string DomainName { get; }
+   public string FirstName { get; }
+   public string GuestHost { get; }
+   public string LastName { get; }
+   public string PrincipalName { get; }
+   public string ProviderName { get; }
+   public string SessionInitiationProtocolUri { get; }
+ }

+ public enum Windows.System.LaunchUriStatus {
+   Success = 0,
+   AppUnavailable = 1,
+   ProtocolUnavailable = 2,
+   Unknown = 3,
+ }

+ public enum Windows.System.LaunchUriType {
+   LaunchUri = 0,
+   LaunchUriForResults = 1,
+ }

| public class Windows.System.Launcher {
+   public static IAsyncOperation<bool> LaunchFolderAsync( IStorageFolder operation );
+   public static IAsyncOperation<bool> LaunchFolderAsync( IStorageFolder operation, FolderLauncherOptions folder );
+   public static IAsyncOperation<bool> LaunchUriForResultsAndContinueAsync( Uri operation, LauncherOptions uri, ValueSet options );
+   public static IAsyncOperation<bool> LaunchUriForResultsAndContinueAsync( Uri operation, LauncherOptions uri, ValueSet options, ValueSet continuationData );
+   public static IAsyncOperation<QueryUriSupportStatus> QueryUriSupportAsync( Uri operation, LaunchUriType uri );
+   public static IAsyncOperation<QueryUriSupportStatus> QueryUriSupportAsync( Uri operation, LaunchUriType uri, string launchUriType );
| }

| public class Windows.System.LauncherOptions {
+   public string TargetApplicationPackageFamilyName { get; set; }
| }

+ public class Windows.System.PowerManager {
+   public BatteryStatus BatteryStatus { get; }
+   public PowerSavingStatus PowerSavingStatus { get; }
+   public PowerSupplyStatus PowerSupplyStatus { get; }
+   public int RemainingChargePercent { get; }
+   EventHandler<object> BatteryStatusChanged;
+   EventHandler<object> PowerSavingStatusChanged;
+   EventHandler<object> PowerSupplyStatusChanged;
+   EventHandler<object> RemainingChargePercentChanged;
+ }

+ public enum Windows.System.PowerSavingStatus {
+   Disabled = 0,
+   Off = 1,
+   On = 2,
+ }

+ public enum Windows.System.PowerSupplyStatus {
+   NotPresent = 0,
+   Inadequate = 1,
+   Adequate = 2,
+ }

+ public class Windows.System.ProtocolForResultsOperation {
+   public void ReportCompleted( ValueSet data );
+ }

+ public enum Windows.System.QueryUriSupportStatus {
+   Success = 0,
+   AppNotInstalled = 1,
+   AppUnavailable = 2,
+   ProtocolUnavailable = 3,
+   Unknown = 4,
+ }

+ public class Windows.System.User {
+   public UserAuthenticationStatus AuthenticationStatus { get; }
+   public string DisplayName { get; }
+   public string NonRoamableId { get; }
+   public IPropertySet Properties { get; }
+   public UserType Type { get; }
+   public IRandomAccessStreamReference GetPicture( UserPictureSize value );
+   public static UserWatcher CreateWatcher();
+   public static IAsyncOperation<IVectorView<User>> FindAllAsync();
+   public static IAsyncOperation<IVectorView<User>> FindAllAsync( UserType operation );
+   public static IAsyncOperation<IVectorView<User>> FindAllAsync( UserType operation, UserAuthenticationStatus type );
+   public static User GetFromId( string value );
+ }

+ public enum Windows.System.UserAuthenticationStatus {
+   Unauthenticated = 0,
+   LocallyAuthenticated = 1,
+   RemotelyAuthenticated = 2,
+ }

+ public class Windows.System.UserAuthenticationStatusChangeDeferral {
+   public void Complete();
+ }

+ public class Windows.System.UserAuthenticationStatusChangingEventArgs {
+   public UserAuthenticationStatus CurrentStatus { get; }
+   public UserAuthenticationStatus NewStatus { get; }
+   public User User { get; }
+   public UserAuthenticationStatusChangeDeferral GetDeferral();
+ }

+ public class Windows.System.UserChangedEventArgs {
+   public User User { get; }
+ }

+ public enum Windows.System.UserPictureSize {
+   Size64x64 = 0,
+   Size208x208 = 1,
+   Size424x424 = 2,
+   Size1080x1080 = 3,
+ }

+ public enum Windows.System.UserType {
+   LocalUser = 0,
+   RemoteUser = 1,
+   LocalGuest = 2,
+   RemoteGuest = 3,
+ }

+ public class Windows.System.UserWatcher {
+   public UserWatcherStatus Status { get; }
+   public void Start();
+   public void Stop();
+   TypedEventHandler<UserWatcher, UserChangedEventArgs> Added;
+   TypedEventHandler<UserWatcher, UserChangedEventArgs> AuthenticationStatusChanged;
+   TypedEventHandler<UserWatcher, UserAuthenticationStatusChangingEventArgs> AuthenticationStatusChanging;
+   TypedEventHandler<UserWatcher, object> EnumerationCompleted;
+   TypedEventHandler<UserWatcher, UserChangedEventArgs> Removed;
+   TypedEventHandler<UserWatcher, object> Stopped;
+   TypedEventHandler<UserWatcher, UserChangedEventArgs> Updated;
+ }

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

| public enum Windows.System.VirtualKey {
+   NavigationA = 193,
+   NavigationB = 194,
+   NavigationX = 195,
+   NavigationY = 196,
+   NavigationUp = 197,
+   NavigationDown = 198,
+   NavigationLeft = 199,
+   NavigationRight = 200,
+   NavigationMenu = 201,
+   NavigationView = 202,
+   NavigationViewUp = 203,
+   NavigationViewDown = 204,
+   NavigationViewPrevious = 205,
+   NavigationViewNext = 206,
| }

+ public class Windows.UI.Core.CoreInput {
+   public bool IsInputEnabled { get; set; }
+   public CoreDispatcher Dispatcher { get; }
+   public CoreCursor PointerCursor { get; set; }
+   public bool HasCapture { get; }
+   public Point PointerPosition { get; }
+   public CoreInput();
+   public void ReleasePointerCapture();
+   public void SetPointerCapture();
+   TypedEventHandler<object, InputEnabledEventArgs> InputEnabled;
+   TypedEventHandler<object, PointerEventArgs> PointerCaptureLost;
+   TypedEventHandler<object, PointerEventArgs> PointerEntered;
+   TypedEventHandler<object, PointerEventArgs> PointerExited;
+   TypedEventHandler<object, PointerEventArgs> PointerMoved;
+   TypedEventHandler<object, PointerEventArgs> PointerPressed;
+   TypedEventHandler<object, PointerEventArgs> PointerReleased;
+   TypedEventHandler<object, PointerEventArgs> PointerWheelChanged;
+ }

| public class Windows.UI.Core.CoreWindow {
-   public KeyboardInputBuffer KeyboardInputBuffer { get; set; }
-   public bool IsKeyboardInputEnabled { get; set; }
| }

+ public interface Windows.UI.Core.ICorePointerRedirector {
+   TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerAcquired;
+   TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerEnded;
+   TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerSuspended;
+ }

+ public class Windows.UI.Core.Text.CoreTextCompositionCompletedEventArgs {
+   public IVectorView<CoreTextCompositionSegment> CompositionSegments { get; }
+   public bool IsCanceled { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextCompositionSegment {
+   public CoreTextRange Range { get; set; }
+   public string PreconversionString { get; set; }
+ }

+ public class Windows.UI.Core.Text.CoreTextCompositionStartedEventArgs {
+   public bool IsCanceled { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextCurrentInputLanguageChangedEventArgs {
+   public Language InputLanguage { get; }
+ }

+ public class Windows.UI.Core.Text.CoreTextEditContext {
+   public string Name { get; set; }
+   public bool IsReadOnly { get; set; }
+   public CoreTextInputScope InputScope { get; set; }
+   public CoreTextInputPaneDisplayPolicy InputPaneDisplayPolicy { get; set; }
+   public void NotifyFocusEnter();
+   public void NotifyFocusLeave();
+   public void NotifyTextChanged( CoreTextRange modifiedRange, int newLength, CoreTextRange newSelection );
+   public void NotifySelectionChanged( CoreTextRange selection );
+   public void NotifyLayoutChanged();
+   TypedEventHandler<CoreTextEditContext, CoreTextCompositionCompletedEventArgs> CompositionCompleted;
+   TypedEventHandler<CoreTextEditContext, CoreTextCompositionStartedEventArgs> CompositionStarted;
+   TypedEventHandler<CoreTextEditContext, object> FocusRemoved;
+   TypedEventHandler<CoreTextEditContext, CoreTextFormatUpdatingEventArgs> FormatUpdating;
+   TypedEventHandler<CoreTextEditContext, CoreTextLayoutRequestedEventArgs> LayoutRequested;
+   TypedEventHandler<CoreTextEditContext, CoreTextSelectionRequestedEventArgs> SelectionRequested;
+   TypedEventHandler<CoreTextEditContext, CoreTextSelectionUpdatingEventArgs> SelectionUpdating;
+   TypedEventHandler<CoreTextEditContext, CoreTextTextRequestedEventArgs> TextRequested;
+   TypedEventHandler<CoreTextEditContext, CoreTextTextUpdatingEventArgs> TextUpdating;
+ }

+ public class Windows.UI.Core.Text.CoreTextFormatUpdatingEventArgs {
+   public CoreTextFormatUpdatingResult Result { get; set; }
+   public IReference<UIElementType> BackgroundColor { get; }
+   public bool IsCanceled { get; }
+   public CoreTextRange Range { get; }
+   public CoreTextFormatUpdatingReason Reason { get; }
+   public IReference<UIElementType> TextColor { get; }
+   public IReference<UIElementType> UnderlineColor { get; }
+   public IReference<UnderlineType> UnderlineType { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public enum Windows.UI.Core.Text.CoreTextFormatUpdatingReason {
+   None = 0,
+   CompositionUnconverted = 1,
+   CompositionConverted = 2,
+   CompositionTargetUnconverted = 3,
+   CompositionTargetConverted = 4,
+ }

+ public enum Windows.UI.Core.Text.CoreTextFormatUpdatingResult {
+   Succeeded = 0,
+   Failed = 1,
+ }

+ public enum Windows.UI.Core.Text.CoreTextInputPaneDisplayPolicy {
+   Automatic = 0,
+   Manual = 1,
+ }

+ public enum Windows.UI.Core.Text.CoreTextInputScope {
+   Default = 0,
+   Url = 1,
+   FilePath = 2,
+   FileName = 3,
+   EmailUserName = 4,
+   EmailAddress = 5,
+   UserName = 6,
+   PersonalFullName = 7,
+   PersonalNamePrefix = 8,
+   PersonalGivenName = 9,
+   PersonalMiddleName = 10,
+   PersonalSurname = 11,
+   PersonalNameSuffix = 12,
+   Address = 13,
+   AddressPostalCode = 14,
+   AddressStreet = 15,
+   AddressStateOrProvince = 16,
+   AddressCity = 17,
+   AddressCountryName = 18,
+   AddressCountryShortName = 19,
+   CurrencyAmountAndSymbol = 20,
+   CurrencyAmount = 21,
+   Date = 22,
+   DateMonth = 23,
+   DateDay = 24,
+   DateYear = 25,
+   DateMonthName = 26,
+   DateDayName = 27,
+   Number = 29,
+   SingleCharacter = 30,
+   Password = 31,
+   TelephoneNumber = 32,
+   TelephoneCountryCode = 33,
+   TelephoneAreaCode = 34,
+   TelephoneLocalNumber = 35,
+   Time = 36,
+   TimeHour = 37,
+   TimeMinuteOrSecond = 38,
+   NumberFullWidth = 39,
+   AlphanumericHalfWidth = 40,
+   AlphanumericFullWidth = 41,
+   CurrencyChinese = 42,
+   Bopomofo = 43,
+   Hiragana = 44,
+   KatakanaHalfWidth = 45,
+   KatakanaFullWidth = 46,
+   Hanja = 47,
+   HangulHalfWidth = 48,
+   HangulFullWidth = 49,
+   Search = 50,
+   Formula = 51,
+   SearchIncremental = 52,
+   ChineseHalfWidth = 53,
+   ChineseFullWidth = 54,
+   NativeScript = 55,
+   Text = 57,
+   Chat = 58,
+   NameOrPhoneNumber = 59,
+   EmailUserNameOrAddress = 60,
+   Private = 61,
+   Maps = 62,
+   PasswordNumeric = 63,
+   FormulaNumber = 67,
+ }

+ public class Windows.UI.Core.Text.CoreTextInputServiceContext {
+   public Language CurrentInputLanguage { get; }
+   TypedEventHandler<CoreTextInputServiceContext, CoreTextCurrentInputLanguageChangedEventArgs> CurrentInputLanguageChanged;
+ }

+ public class Windows.UI.Core.Text.CoreTextLayoutBounds {
+   public Rect TextBounds { get; set; }
+   public Rect ControlBounds { get; set; }
+ }

+ public class Windows.UI.Core.Text.CoreTextLayoutRequestedEventArgs {
+   public bool IsCanceled { get; }
+   public CoreTextLayoutBounds LayoutBounds { get; }
+   public CoreTextRange Range { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public struct Windows.UI.Core.Text.CoreTextRange {
+   public int StartCaretPosition;
+   public int EndCaretPosition;
+ }

+ public class Windows.UI.Core.Text.CoreTextRequestDeferral {
+   public void Complete();
+ }

+ public class Windows.UI.Core.Text.CoreTextSelectionRequestedEventArgs {
+   public CoreTextRange Selection { get; set; }
+   public bool IsCanceled { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextSelectionUpdatingEventArgs {
+   public CoreTextSelectionUpdatingResult Result { get; set; }
+   public bool IsCanceled { get; }
+   public CoreTextRange Selection { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public enum Windows.UI.Core.Text.CoreTextSelectionUpdatingResult {
+   Succeeded = 0,
+   Failed = 1,
+ }

+ public class Windows.UI.Core.Text.CoreTextServicesConstants {
+   public char HiddenCharacter { get; }
+ }

+ public class Windows.UI.Core.Text.CoreTextServicesManager {
+   public CoreTextInputServiceContext InputServiceContext { get; }
+   public CoreTextEditContext CreateEditContext();
+   public static CoreTextServicesManager GetForCurrentView();
+ }

+ public class Windows.UI.Core.Text.CoreTextTextRequestedEventArgs {
+   public string Text { get; set; }
+   public bool IsCanceled { get; }
+   public CoreTextRange Range { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public class Windows.UI.Core.Text.CoreTextTextUpdatingEventArgs {
+   public CoreTextTextUpdatingResult Result { get; set; }
+   public bool IsCanceled { get; }
+   public CoreTextRange NewSelection { get; }
+   public CoreTextRange Range { get; }
+   public string Text { get; }
+   public CoreTextRequestDeferral GetDeferral();
+ }

+ public enum Windows.UI.Core.Text.CoreTextTextUpdatingResult {
+   Succeeded = 0,
+   Failed = 1,
+ }

| public enum Windows.UI.Notifications.TileTemplateType {
+   TileTall150x310Image = 79,
| }

+ public enum Windows.UI.Notifications.ToastHistoryChangedType {
+   Cleared = 0,
+   Removed = 1,
+   Expired = 2,
+   Added = 3,
+ }

| public class Windows.UI.Notifications.ToastNotificationHistory {
+   public IVectorView<ToastNotification> GetHistory();
+   public IVectorView<ToastNotification> GetHistory( string toasts );
| }

+ public class Windows.UI.Notifications.ToastNotificationHistoryChangedTriggerDetail {
+   public ToastHistoryChangedType ChangeType { get; }
+ }

| public class Windows.UI.ViewManagement.ApplicationView {
+   public FullScreenSystemOverlayMode FullScreenSystemOverlayMode { get; set; }
+   public bool IsFullScreenMode { get; }
+   public ApplicationViewTitleBar TitleBar { get; }
+   public bool TryEnterFullScreenMode();
+   public void ExitFullScreenMode();
+   public void ShowStandardSystemOverlays();
| }

+ public class Windows.UI.ViewManagement.ApplicationViewTitleBar {
+   public IReference<Color> ButtonPressedBackgroundColor { get; set; }
+   public IReference<Color> ButtonHoverForegroundColor { get; set; }
+   public IReference<Color> ButtonHoverBackgroundColor { get; set; }
+   public IReference<Color> ButtonForegroundColor { get; set; }
+   public IReference<Color> ButtonBackgroundColor { get; set; }
+   public IReference<Color> BackgroundColor { get; set; }
+   public IReference<Color> ButtonPressedForegroundColor { get; set; }
+   public IReference<Color> ForegroundColor { get; set; }
+   public bool ExtendViewIntoTitleBar { get; set; }
+   public double Height { get; }
+   public bool IsVisible { get; }
+   public double SystemOverlayLeftInset { get; }
+   public double SystemOverlayRightInset { get; }
+   TypedEventHandler<ApplicationViewTitleBar, object> IsVisibleChanged;
+   TypedEventHandler<ApplicationViewTitleBar, object> LayoutMetricsChanged;
+ }

+ public enum Windows.UI.ViewManagement.FullScreenSystemOverlayMode {
+   Standard = 0,
+   Minimal = 1,
+ }

+ public class Windows.UI.ViewManagement.ProjectionManager {
+   public bool ProjectionDisplayAvailable { get; }
+   public static IAsyncAction StartProjectingAsync( int operation, int projectionViewId );
+   public static IAsyncAction SwapDisplaysForViewsAsync( int operation, int projectionViewId );
+   public static IAsyncAction StopProjectingAsync( int operation, int projectionViewId );
+   EventHandler<object> ProjectionDisplayAvailableChanged;
+ }

+ public enum Windows.UI.ViewManagement.ViewSizePreference {
+   Default = 0,
+   UseLess = 1,
+   UseHalf = 2,
+   UseMore = 3,
+   UseMinimum = 4,
+   UseNone = 5,
+ }

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

+ public class Windows.UI.WebUI.WebUIWebAccountProviderContinuationEventArgs {
+   public ActivationKind Kind { get; }
+   public ApplicationExecutionState PreviousExecutionState { get; }
+   public SplashScreen SplashScreen { get; }
+   public WebTokenRequestResult Result { get; }
+   public ActivatedOperation ActivatedOperation { get; }
+ }

+ public class Windows.UI.Xaml.AdaptiveTrigger : Windows.UI.Xaml.StateTrigger {
+   public double MinWindowWidth { get; set; }
+   public double MinWindowHeight { get; set; }
+   public DependencyProperty MinWindowHeightProperty { get; }
+   public DependencyProperty MinWindowWidthProperty { get; }
+   public AdaptiveTrigger();
+ }

+ public enum Windows.UI.Xaml.AutomationTextAttributesEnum {
+   AnimationStyleAttribute = 40000,
+   BackgroundColorAttribute = 40001,
+   BulletStyleAttribute = 40002,
+   CapStyleAttribute = 40003,
+   CultureAttribute = 40004,
+   FontNameAttribute = 40005,
+   FontSizeAttribute = 40006,
+   FontWeightAttribute = 40007,
+   ForegroundColorAttribute = 40008,
+   HorizontalTextAlignmentAttribute = 40009,
+   IndentationFirstLineAttribute = 40010,
+   IndentationLeadingAttribute = 40011,
+   IndentationTrailingAttribute = 40012,
+   IsHiddenAttribute = 40013,
+   IsItalicAttribute = 40014,
+   IsReadOnlyAttribute = 40015,
+   IsSubscriptAttribute = 40016,
+   IsSuperscriptAttribute = 40017,
+   MarginBottomAttribute = 40018,
+   MarginLeadingAttribute = 40019,
+   MarginTopAttribute = 40020,
+   MarginTrailingAttribute = 40021,
+   OutlineStylesAttribute = 40022,
+   OverlineColorAttribute = 40023,
+   OverlineStyleAttribute = 40024,
+   StrikethroughColorAttribute = 40025,
+   StrikethroughStyleAttribute = 40026,
+   TabsAttribute = 40027,
+   TextFlowDirectionsAttribute = 40028,
+   UnderlineColorAttribute = 40029,
+   UnderlineStyleAttribute = 40030,
+   AnnotationTypesAttribute = 40031,
+   AnnotationObjectsAttribute = 40032,
+   StyleNameAttribute = 40033,
+   StyleIdAttribute = 40034,
+   LinkAttribute = 40035,
+   IsActiveAttribute = 40036,
+   SelectionActiveEndAttribute = 40037,
+   CaretPositionAttribute = 40038,
+   CaretBidiModeAttribute = 40039,
+ }

| public class Windows.UI.Xaml.DataTemplate : Windows.UI.Xaml.FrameworkTemplate {
+   public TypeName TargetType { get; set; }
+   public DependencyProperty ExtensionInstanceProperty { get; }
+   public static IDataTemplateExtension GetExtensionInstance( FrameworkElement value );
+   public static void SetExtensionInstance( FrameworkElement element, IDataTemplateExtension value );
| }

| public class Windows.UI.Xaml.DependencyObject {
+   public long RegisterPropertyChangedCallback( DependencyProperty returnValue, DependencyPropertyChangedCallback dp );
+   public void UnregisterPropertyChangedCallback( DependencyProperty dp, long token );
| }

+ public void delegate Windows.UI.Xaml.DependencyPropertyChangedCallback( DependencyObject sender, DependencyProperty dp );

+ public class Windows.UI.Xaml.DragOperationDeferral {
+   public void Complete();
+ }

+ public class Windows.UI.Xaml.DragStartingEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public Point DragVisualOffset { get; set; }
+   public DragVisualKind DragVisualKind { get; set; }
+   public DragVisual DragVisual { get; set; }
+   public bool Cancel { get; set; }
+   public DataPackage Data { get; }
+ }

+ public class Windows.UI.Xaml.DragVisual {
+   public static DragVisual CreateFromBitmap( BitmapImage returnValue );
+ }

+ public enum Windows.UI.Xaml.DragVisualKind {
+   Automatic = 0,
+   DraggedUIElement = 1,
+   CustomDragVisual = 2,
+   DataFormat = 3,
+ }

+ public class Windows.UI.Xaml.DropCompletedEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public DataPackageOperation DropResult { get; }
+ }

+ public interface Windows.UI.Xaml.IDataTemplateExtension {
+   public void ResetTemplate();
+   public bool ProcessBinding( uint returnValue );
+ }

| public class Windows.UI.Xaml.Setter : Windows.UI.Xaml.SetterBase {
+   public TargetPropertyPath Target { get; set; }
| }

+ public class Windows.UI.Xaml.StateTrigger : Windows.UI.Xaml.DependencyObject {
+   protected StateTrigger();
+ }

+ public class Windows.UI.Xaml.TargetPropertyPath {
+   public object Target { get; set; }
+   public PropertyPath Path { get; set; }
+   public TargetPropertyPath();
+ }

| public class Windows.UI.Xaml.UIElement : Windows.UI.Xaml.DependencyObject {
+   public Transform3D Transform3D { get; set; }
+   public bool CanDrag { get; set; }
+   public DependencyProperty CanDragProperty { get; }
+   public DependencyProperty Transform3DProperty { get; }
+   public IAsyncOperation<DataPackageOperation> StartDragAsync( PointerPoint returnValue );
| }

| public class Windows.UI.Xaml.VisualState : Windows.UI.Xaml.DependencyObject {
+   public SetterBaseCollection Setters { get; }
+   public IVector<StateTrigger> StateTriggers { get; }
| }

+ public enum Windows.UI.Xaml.Automation.AutomationActiveEnd {
+   None = 0,
+   Start = 1,
+   End = 2,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationAnimationStyle {
+   None = 0,
+   LasVegasLights = 1,
+   BlinkingBackground = 2,
+   SparkleText = 3,
+   MarchingBlackAnts = 4,
+   MarchingRedAnts = 5,
+   Shimmer = 6,
+   Other = 7,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationBulletStyle {
+   None = 0,
+   HollowRoundBullet = 1,
+   FilledRoundBullet = 2,
+   HollowSquareBullet = 3,
+   FilledSquareBullet = 4,
+   DashBullet = 5,
+   Other = 6,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationCaretBidiMode {
+   LTR = 0,
+   RTL = 1,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationCaretPosition {
+   Unknown = 0,
+   EndOfLine = 1,
+   BeginningOfLine = 2,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationFlowDirections {
+   Default = 0,
+   RightToLeft = 1,
+   BottomToTop = 2,
+   Vertical = 3,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationOutlineStyles {
+   None = 0,
+   Outline = 1,
+   Shadow = 2,
+   Engraved = 3,
+   Embossed = 4,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationStyleId {
+   Heading1 = 70001,
+   Heading2 = 70002,
+   Heading3 = 70003,
+   Heading4 = 70004,
+   Heading5 = 70005,
+   Heading6 = 70006,
+   Heading7 = 70007,
+   Heading8 = 70008,
+   Heading9 = 70009,
+   Title = 70010,
+   Subtitle = 70011,
+   Normal = 70012,
+   Emphasis = 70013,
+   Quote = 70014,
+   BulletedList = 70015,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationTextDecorationLineStyle {
+   None = 0,
+   Single = 1,
+   WordsOnly = 2,
+   Double = 3,
+   Dot = 4,
+   Dash = 5,
+   DashDot = 6,
+   DashDotDot = 7,
+   Wavy = 8,
+   ThickSingle = 9,
+   DoubleWavy = 10,
+   ThickWavy = 11,
+   LongDash = 12,
+   ThickDash = 13,
+   ThickDashDot = 14,
+   ThickDashDotDot = 15,
+   ThickDot = 16,
+   ThickLongDash = 17,
+   Other = 18,
+ }

+ public enum Windows.UI.Xaml.Automation.AutomationTextEditChangeType {
+   None = 0,
+   AutoCorrect = 1,
+   Composition = 2,
+   CompositionFinalized = 3,
+ }

+ public enum Windows.UI.Xaml.Automation.Peers.AutomationNavigationDirection {
+   Parent = 0,
+   NextSibling = 1,
+   PreviousSibling = 2,
+   FirstChild = 3,
+   LastChild = 4,
+ }

| public class Windows.UI.Xaml.Automation.Peers.AutomationPeer : Windows.UI.Xaml.DependencyObject {
+   public object Navigate( AutomationNavigationDirection returnValue );
+   public object GetElementFromPoint( Point returnValue );
+   public object GetFocusedElement();
+   public void RaiseTextEditTextChangedEvent( AutomationTextEditChangeType automationTextEditChangeType, IVectorView<string> changedData );
+   public void RaiseStructureChangedEvent( AutomationStructureChangeType structureChangeType, AutomationPeer child );
+   public static RawElementProviderRuntimeId GenerateRawElementProviderRuntimeId();
| }

+ public enum Windows.UI.Xaml.Automation.Peers.AutomationStructureChangeType {
+   ChildAdded = 0,
+   ChildRemoved = 1,
+   ChildrenInvalidated = 2,
+   ChildrenBulkAdded = 3,
+   ChildrenBulkRemoved = 4,
+   ChildrenReordered = 5,
+ }

| public enum Windows.UI.Xaml.Automation.Peers.PatternInterface {
+   TextEdit = 32,
| }

+ public struct Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId {
+   public uint Part1;
+   public uint Part2;
+ }

+ public interface Windows.UI.Xaml.Automation.Provider.ITextEditProvider {
+   public ITextRangeProvider GetActiveComposition();
+   public ITextRangeProvider GetConversionTarget();
+ }

| public enum Windows.UI.Xaml.Controls.AppBarClosedDisplayMode {
+   Hidden = 2,
| }

+ public class Windows.UI.Xaml.Controls.CalendarPicker : Windows.UI.Xaml.Controls.Control {
+   public DayOfWeek FirstDayOfWeek { get; set; }
+   public CalendarViewDisplayMode DisplayMode { get; set; }
+   public string DayOfWeekFormat { get; set; }
+   public DateTime Date { get; set; }
+   public Style CalendarViewStyle { get; set; }
+   public string CalendarIdentifier { get; set; }
+   public string DateFormat { get; set; }
+   public bool IsCalendarOpen { get; set; }
+   public IIterable<string> Languages { get; set; }
+   public string PlaceholderText { get; set; }
+   public DateTime MinDate { get; set; }
+   public DateTime MaxDate { get; set; }
+   public bool IsTodayHighlighted { get; set; }
+   public bool IsOutOfScopeEnabled { get; set; }
+   public bool IsLabelVisible { get; set; }
+   public DependencyProperty CalendarIdentifierProperty { get; }
+   public DependencyProperty CalendarViewStyleProperty { get; }
+   public DependencyProperty DateFormatProperty { get; }
+   public DependencyProperty DateProperty { get; }
+   public DependencyProperty DayOfWeekFormatProperty { get; }
+   public DependencyProperty DisplayModeProperty { get; }
+   public DependencyProperty FirstDayOfWeekProperty { get; }
+   public DependencyProperty IsCalendarOpenProperty { get; }
+   public DependencyProperty IsLabelVisibleProperty { get; }
+   public DependencyProperty IsOutOfScopeEnabledProperty { get; }
+   public DependencyProperty IsTodayHighlightedProperty { get; }
+   public DependencyProperty LanguagesProperty { get; }
+   public DependencyProperty MaxDateProperty { get; }
+   public DependencyProperty MinDateProperty { get; }
+   public DependencyProperty PlaceholderTextProperty { get; }
+   public CalendarPicker();
+   public void SetDisplayDate( DateTime date );
+   public void SetYearDecadeDisplayDimensions( int columns, int rows );
+   TypedEventHandler<CalendarPicker, CalendarPickerSelectedDateChangedEventArgs> CalendarPickerSelectedDateChanged;
+   TypedEventHandler<CalendarPicker, CalendarPickerSelectedDateErrorEventArgs> CalendarPickerSelectedDateError;
+   Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventHandler CalendarViewDayItemChanging;
+   EventHandler<object> Closed;
+   EventHandler<object> Opened;
+ }

+ public class Windows.UI.Xaml.Controls.CalendarPickerSelectedDateChangedEventArgs {
+   public IReference<DateTime> NewDate { get; }
+   public IReference<DateTime> OldDate { get; }
+ }

+ public class Windows.UI.Xaml.Controls.CalendarPickerSelectedDateErrorEventArgs {
+   public DateTime IncorrectValue { get; }
+   public string Message { get; }
+ }

+ public class Windows.UI.Xaml.Controls.CalendarView : Windows.UI.Xaml.Controls.Control {
+   public Brush CalendarItemForeground { get; set; }
+   public Thickness CalendarItemBorderThickness { get; set; }
+   public Brush CalendarItemBorderBrush { get; set; }
+   public Brush CalendarItemBackground { get; set; }
+   public string CalendarIdentifier { get; set; }
+   public Brush BlackoutForeground { get; set; }
+   public Brush SelectedPressedBorderBrush { get; set; }
+   public CalendarViewDisplayMode DisplayMode { get; set; }
+   public string DayOfWeekFormat { get; set; }
+   public FontWeight DayItemFontWeight { get; set; }
+   public FontStyle DayItemFontStyle { get; set; }
+   public double DayItemFontSize { get; set; }
+   public FontFamily DayItemFontFamily { get; set; }
+   public double FirstOfYearDecadeLabelFontSize { get; set; }
+   public FontFamily FirstOfYearDecadeLabelFontFamily { get; set; }
+   public FontWeight FirstOfMonthLabelFontWeight { get; set; }
+   public FontStyle FirstOfMonthLabelFontStyle { get; set; }
+   public double FirstOfMonthLabelFontSize { get; set; }
+   public FontFamily FirstOfMonthLabelFontFamily { get; set; }
+   public FontFamily MonthYearItemFontFamily { get; set; }
+   public DayOfWeek FirstDayOfWeek { get; set; }
+   public Brush HoverBorderBrush { get; set; }
+   public HorizontalAlignment HorizontalFirstOfMonthLabelAlignment { get; set; }
+   public HorizontalAlignment HorizontalDayItemAlignment { get; set; }
+   public Brush FocusBorderBrush { get; set; }
+   public FontWeight FirstOfYearDecadeLabelFontWeight { get; set; }
+   public FontStyle FirstOfYearDecadeLabelFontStyle { get; set; }
+   public bool IsLabelVisible { get; set; }
+   public DateTime MinDate { get; set; }
+   public DateTime MaxDate { get; set; }
+   public bool IsTodayHighlighted { get; set; }
+   public bool IsOutOfScopeEnabled { get; set; }
+   public Brush OutOfScopeForeground { get; set; }
+   public Brush OutOfScopeBackground { get; set; }
+   public int NumberOfWeeksInView { get; set; }
+   public FontWeight MonthYearItemFontWeight { get; set; }
+   public FontStyle MonthYearItemFontStyle { get; set; }
+   public double MonthYearItemFontSize { get; set; }
+   public Brush SelectedHoverBorderBrush { get; set; }
+   public Brush SelectedForeground { get; set; }
+   public Style CalendarViewDayItemStyle { get; set; }
+   public Brush SelectedBorderBrush { get; set; }
+   public Brush PressedForeground { get; set; }
+   public Brush PressedBorderBrush { get; set; }
+   public VerticalAlignment VerticalFirstOfMonthLabelAlignment { get; set; }
+   public VerticalAlignment VerticalDayItemAlignment { get; set; }
+   public Brush TodayForeground { get; set; }
+   public IIterable<string> Languages { get; set; }
+   public FontWeight TodayFontWeight { get; set; }
+   public CalendarViewSelectionMode SelectionMode { get; set; }
+   public IVector<DateTime> SelectedDates { get; }
+   public CalendarViewTemplateSettings TemplateSettings { get; }
+   public DependencyProperty BlackoutForegroundProperty { get; }
+   public DependencyProperty CalendarIdentifierProperty { get; }
+   public DependencyProperty CalendarItemBackgroundProperty { get; }
+   public DependencyProperty CalendarItemBorderBrushProperty { get; }
+   public DependencyProperty CalendarItemBorderThicknessProperty { get; }
+   public DependencyProperty CalendarItemForegroundProperty { get; }
+   public DependencyProperty CalendarViewDayItemStyleProperty { get; }
+   public DependencyProperty DayItemFontFamilyProperty { get; }
+   public DependencyProperty DayItemFontSizeProperty { get; }
+   public DependencyProperty DayItemFontStyleProperty { get; }
+   public DependencyProperty DayItemFontWeightProperty { get; }
+   public DependencyProperty DayOfWeekFormatProperty { get; }
+   public DependencyProperty DisplayModeProperty { get; }
+   public DependencyProperty FirstDayOfWeekProperty { get; }
+   public DependencyProperty FirstOfMonthLabelFontFamilyProperty { get; }
+   public DependencyProperty FirstOfMonthLabelFontSizeProperty { get; }
+   public DependencyProperty FirstOfMonthLabelFontStyleProperty { get; }
+   public DependencyProperty FirstOfMonthLabelFontWeightProperty { get; }
+   public DependencyProperty FirstOfYearDecadeLabelFontFamilyProperty { get; }
+   public DependencyProperty FirstOfYearDecadeLabelFontSizeProperty { get; }
+   public DependencyProperty FirstOfYearDecadeLabelFontStyleProperty { get; }
+   public DependencyProperty FirstOfYearDecadeLabelFontWeightProperty { get; }
+   public DependencyProperty FocusBorderBrushProperty { get; }
+   public DependencyProperty HorizontalDayItemAlignmentProperty { get; }
+   public DependencyProperty HorizontalFirstOfMonthLabelAlignmentProperty { get; }
+   public DependencyProperty HoverBorderBrushProperty { get; }
+   public DependencyProperty IsLabelVisibleProperty { get; }
+   public DependencyProperty IsOutOfScopeEnabledProperty { get; }
+   public DependencyProperty IsTodayHighlightedProperty { get; }
+   public DependencyProperty LanguagesProperty { get; }
+   public DependencyProperty MaxDateProperty { get; }
+   public DependencyProperty MinDateProperty { get; }
+   public DependencyProperty MonthYearItemFontFamilyProperty { get; }
+   public DependencyProperty MonthYearItemFontSizeProperty { get; }
+   public DependencyProperty MonthYearItemFontStyleProperty { get; }
+   public DependencyProperty MonthYearItemFontWeightProperty { get; }
+   public DependencyProperty NumberOfWeeksInViewProperty { get; }
+   public DependencyProperty OutOfScopeBackgroundProperty { get; }
+   public DependencyProperty OutOfScopeForegroundProperty { get; }
+   public DependencyProperty PressedBorderBrushProperty { get; }
+   public DependencyProperty PressedForegroundProperty { get; }
+   public DependencyProperty SelectedBorderBrushProperty { get; }
+   public DependencyProperty SelectedDatesProperty { get; }
+   public DependencyProperty SelectedForegroundProperty { get; }
+   public DependencyProperty SelectedHoverBorderBrushProperty { get; }
+   public DependencyProperty SelectedPressedBorderBrushProperty { get; }
+   public DependencyProperty SelectionModeProperty { get; }
+   public DependencyProperty TemplateSettingsProperty { get; }
+   public DependencyProperty TodayFontWeightProperty { get; }
+   public DependencyProperty TodayForegroundProperty { get; }
+   public DependencyProperty VerticalDayItemAlignmentProperty { get; }
+   public DependencyProperty VerticalFirstOfMonthLabelAlignmentProperty { get; }
+   public CalendarView();
+   public void SetDisplayDate( DateTime date );
+   public void SetYearDecadeDisplayDimensions( int columns, int rows );
+   TypedEventHandler<CalendarView, CalendarViewDayItemChangingEventArgs> CalendarViewDayItemChanging;
+   TypedEventHandler<CalendarView, SelectedDatesChangedEventArgs> SelectedDatesChanged;
+ }

+ public class Windows.UI.Xaml.Controls.CalendarViewDayItem : Windows.UI.Xaml.Controls.Control {
+   public bool IsBlackout { get; set; }
+   public DateTime Date { get; }
+   public DependencyProperty DateProperty { get; }
+   public DependencyProperty IsBlackoutProperty { get; }
+   public CalendarViewDayItem();
+   public void SetDensityColors( IIterable<Color> colors );
+ }

+ public class Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs {
+   public bool InRecycleQueue { get; }
+   public CalendarViewDayItem Item { get; }
+   public uint Phase { get; }
+   public void RegisterUpdateCallback( TypedEventHandler<CalendarView, CalendarViewDayItemChangingEventArgs> callback );
+   public void RegisterUpdateCallback( uint callbackPhase, TypedEventHandler<CalendarView, CalendarViewDayItemChangingEventArgs> callback );
+ }

+ public void delegate Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventHandler( CalendarView sender, CalendarViewDayItemChangingEventArgs e );

+ public enum Windows.UI.Xaml.Controls.CalendarViewDisplayMode {
+   Month = 0,
+   Year = 1,
+   Decade = 2,
+ }

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

+ public class Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs {
+   public SelectorItem ItemContainer { get; set; }
+   public bool IsContainerPrepared { get; set; }
+   public object Item { get; }
+   public int ItemIndex { get; }
+   public ChoosingItemContainerEventArgs();
+ }

| public class Windows.UI.Xaml.Controls.ContentPresenter : Windows.UI.Xaml.FrameworkElement {
+   public TextWrapping TextWrapping { get; set; }
+   public int MaxLines { get; set; }
+   public LineStackingStrategy LineStackingStrategy { get; set; }
+   public double LineHeight { get; set; }
+   public DependencyProperty LineHeightProperty { get; }
+   public DependencyProperty LineStackingStrategyProperty { get; }
+   public DependencyProperty TextWrappingProperty { get; }
+   public DependencyProperty MaxLinesProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.Control : Windows.UI.Xaml.FrameworkElement {
+   public Style ValidationIndicatorStyle { get; set; }
+   public bool IsValidationIndicatorEnabled { get; set; }
+   public IObservableVector<ControlValidationError> ValidationErrors { get; }
+   public ControlValidationState ValidationState { get; }
+   public DependencyProperty IsValidationIndicatorEnabledProperty { get; }
+   public DependencyProperty ValidationErrorsProperty { get; }
+   public DependencyProperty ValidationIndicatorStyleProperty { get; }
+   public DependencyProperty ValidationStateProperty { get; }
| }

+ public class Windows.UI.Xaml.Controls.ControlValidationError {
+   public IIterable<string> PropertyNames { get; set; }
+   public string Message { get; set; }
+   public ControlValidationError();
+ }

+ public enum Windows.UI.Xaml.Controls.ControlValidationState {
+   Unknown = 0,
+   Valid = 1,
+   Invalid = 2,
+ }

+ public class Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs {
+   public DataPackageOperation DropResult { get; }
+   public IVectorView<object> Items { get; }
+ }

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

| public class Windows.UI.Xaml.Controls.ItemsControl : Windows.UI.Xaml.Controls.Control {
+   public DependencyObject GroupHeaderContainerFromItemContainer( DependencyObject returnValue );
| }

| public class Windows.UI.Xaml.Controls.ItemsStackPanel : Windows.UI.Xaml.Controls.Panel {
+   public bool IsStickyGroupHeadersEnabled { get; set; }
+   public DependencyProperty IsStickyGroupHeadersEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.ItemsWrapGrid : Windows.UI.Xaml.Controls.Panel {
+   public bool IsStickyGroupHeadersEnabled { get; set; }
+   public DependencyProperty IsStickyGroupHeadersEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Controls.ListViewBase : Windows.UI.Xaml.Controls.Primitives.Selector {
+   public IVectorView<ItemIndexRange> SelectedRanges { get; }
+   public bool IsMultiSelectCheckBoxEnabled { get; set; }
+   public DependencyProperty IsMultiSelectCheckBoxEnabledProperty { get; }
+   public void SelectRange( ItemIndexRange itemIndexRange );
+   public void DeselectRange( ItemIndexRange itemIndexRange );
| }

| public class Windows.UI.Xaml.Controls.MediaElement : Windows.UI.Xaml.FrameworkElement {
+   public MediaTransportControls TransportControls { get; set; }
+   public IVector<TimedTextTrack> TimedTextTracks { get; set; }
+   public bool IsTimedTextVisible { get; set; }
+   public DependencyProperty IsTimedTextVisibleProperty { get; }
+   public CastingSource GetAsCastingSource();
| }

+ public class Windows.UI.Xaml.Controls.MediaTransportControls : Windows.UI.Xaml.Controls.Control {
+   public bool IsPlaybackRateButtonVisible { get; set; }
+   public bool IsSeekEnabled { get; set; }
+   public bool IsFullWindowButtonVisible { get; set; }
+   public bool IsFastRewindEnabled { get; set; }
+   public bool IsFastRewindButtonVisible { get; set; }
+   public bool IsFastForwardEnabled { get; set; }
+   public bool IsFastForwardButtonVisible { get; set; }
+   public bool IsCompact { get; set; }
+   public bool IsPlaybackRateEnabled { get; set; }
+   public bool IsZoomEnabled { get; set; }
+   public bool IsZoomButtonVisible { get; set; }
+   public bool IsVolumeEnabled { get; set; }
+   public bool IsVolumeButtonVisible { get; set; }
+   public bool IsStopEnabled { get; set; }
+   public bool IsStopButtonVisible { get; set; }
+   public bool IsFullWindowEnabled { get; set; }
+   public bool IsSeekBarVisible { get; set; }
+   public DependencyProperty IsCompactProperty { get; }
+   public DependencyProperty IsFastForwardButtonVisibleProperty { get; }
+   public DependencyProperty IsFastForwardEnabledProperty { get; }
+   public DependencyProperty IsFastRewindButtonVisibleProperty { get; }
+   public DependencyProperty IsFastRewindEnabledProperty { get; }
+   public DependencyProperty IsFullWindowButtonVisibleProperty { get; }
+   public DependencyProperty IsFullWindowEnabledProperty { get; }
+   public DependencyProperty IsPlaybackRateButtonVisibleProperty { get; }
+   public DependencyProperty IsPlaybackRateEnabledProperty { get; }
+   public DependencyProperty IsSeekBarVisibleProperty { get; }
+   public DependencyProperty IsSeekEnabledProperty { get; }
+   public DependencyProperty IsStopButtonVisibleProperty { get; }
+   public DependencyProperty IsStopEnabledProperty { get; }
+   public DependencyProperty IsVolumeButtonVisibleProperty { get; }
+   public DependencyProperty IsVolumeEnabledProperty { get; }
+   public DependencyProperty IsZoomButtonVisibleProperty { get; }
+   public DependencyProperty IsZoomEnabledProperty { get; }
+   public DependencyProperty DropoutPriorityProperty { get; }
+   public MediaTransportControls();
+   public static int GetDropoutPriority( UIElement value );
+   public static void SetDropoutPriority( UIElement element, int value );
+ }

| public class Windows.UI.Xaml.Controls.MenuFlyout : Windows.UI.Xaml.Controls.Primitives.FlyoutBase {
+   public void ShowAt( UIElement targetElement, Point point );
| }

+ public class Windows.UI.Xaml.Controls.MenuFlyoutSubItem : Windows.UI.Xaml.Controls.MenuFlyoutItemBase {
+   public string Text { get; set; }
+   public IVector<MenuFlyoutItemBase> Items { get; }
+   public DependencyProperty TextProperty { get; }
+   public MenuFlyoutSubItem();
+ }

| public class Windows.UI.Xaml.Controls.PasswordBox : Windows.UI.Xaml.Controls.Control {
+   public PasswordRevealMode PasswordRevealMode { get; set; }
+   public DependencyProperty PasswordRevealModeProperty { get; }
| }

+ public enum Windows.UI.Xaml.Controls.PasswordRevealMode {
+   Peek = 0,
+   Hidden = 1,
+   Visible = 2,
+ }

+ public class Windows.UI.Xaml.Controls.RelativePanel : Windows.UI.Xaml.Controls.Panel {
+   public DependencyProperty AboveProperty { get; }
+   public DependencyProperty AlignBottomWithPanelProperty { get; }
+   public DependencyProperty AlignBottomWithProperty { get; }
+   public DependencyProperty AlignHorizontalCenterWithPanelProperty { get; }
+   public DependencyProperty AlignHorizontalCenterWithProperty { get; }
+   public DependencyProperty AlignLeftWithPanelProperty { get; }
+   public DependencyProperty AlignLeftWithProperty { get; }
+   public DependencyProperty AlignRightWithPanelProperty { get; }
+   public DependencyProperty AlignRightWithProperty { get; }
+   public DependencyProperty AlignTopWithPanelProperty { get; }
+   public DependencyProperty AlignTopWithProperty { get; }
+   public DependencyProperty AlignVerticalCenterWithPanelProperty { get; }
+   public DependencyProperty AlignVerticalCenterWithProperty { get; }
+   public DependencyProperty BelowProperty { get; }
+   public DependencyProperty LeftOfProperty { get; }
+   public DependencyProperty RightOfProperty { get; }
+   public RelativePanel();
+   public static object GetLeftOf( UIElement value );
+   public static void SetLeftOf( UIElement element, object value );
+   public static object GetAbove( UIElement value );
+   public static void SetAbove( UIElement element, object value );
+   public static object GetRightOf( UIElement value );
+   public static void SetRightOf( UIElement element, object value );
+   public static object GetBelow( UIElement value );
+   public static void SetBelow( UIElement element, object value );
+   public static object GetAlignHorizontalCenterWith( UIElement value );
+   public static void SetAlignHorizontalCenterWith( UIElement element, object value );
+   public static object GetAlignVerticalCenterWith( UIElement value );
+   public static void SetAlignVerticalCenterWith( UIElement element, object value );
+   public static object GetAlignLeftWith( UIElement value );
+   public static void SetAlignLeftWith( UIElement element, object value );
+   public static object GetAlignTopWith( UIElement value );
+   public static void SetAlignTopWith( UIElement element, object value );
+   public static object GetAlignRightWith( UIElement value );
+   public static void SetAlignRightWith( UIElement element, object value );
+   public static object GetAlignBottomWith( UIElement value );
+   public static void SetAlignBottomWith( UIElement element, object value );
+   public static bool GetAlignLeftWithPanel( UIElement value );
+   public static void SetAlignLeftWithPanel( UIElement element, bool value );
+   public static bool GetAlignTopWithPanel( UIElement value );
+   public static void SetAlignTopWithPanel( UIElement element, bool value );
+   public static bool GetAlignRightWithPanel( UIElement value );
+   public static void SetAlignRightWithPanel( UIElement element, bool value );
+   public static bool GetAlignBottomWithPanel( UIElement value );
+   public static void SetAlignBottomWithPanel( UIElement element, bool value );
+   public static bool GetAlignHorizontalCenterWithPanel( UIElement value );
+   public static void SetAlignHorizontalCenterWithPanel( UIElement element, bool value );
+   public static bool GetAlignVerticalCenterWithPanel( UIElement value );
+   public static void SetAlignVerticalCenterWithPanel( UIElement element, bool value );
+ }

+ public class Windows.UI.Xaml.Controls.SearchBox : Windows.UI.Xaml.Controls.Control {
+   public bool SearchHistoryEnabled { get; set; }
+   public string SearchHistoryContext { get; set; }
+   public string QueryText { get; set; }
+   public string PlaceholderText { get; set; }
+   public bool FocusOnKeyboardInput { get; set; }
+   public bool ChooseSuggestionOnEnter { get; set; }
+   public DependencyProperty ChooseSuggestionOnEnterProperty { get; }
+   public DependencyProperty FocusOnKeyboardInputProperty { get; }
+   public DependencyProperty PlaceholderTextProperty { get; }
+   public DependencyProperty QueryTextProperty { get; }
+   public DependencyProperty SearchHistoryContextProperty { get; }
+   public DependencyProperty SearchHistoryEnabledProperty { get; }
+   public SearchBox();
+   public void SetLocalContentSuggestionSettings( LocalContentSuggestionSettings settings );
+   TypedEventHandler<SearchBox, RoutedEventArgs> PrepareForFocusOnKeyboardInput;
+   TypedEventHandler<SearchBox, SearchBoxQueryChangedEventArgs> QueryChanged;
+   TypedEventHandler<SearchBox, SearchBoxQuerySubmittedEventArgs> QuerySubmitted;
+   TypedEventHandler<SearchBox, SearchBoxResultSuggestionChosenEventArgs> ResultSuggestionChosen;
+   TypedEventHandler<SearchBox, SearchBoxSuggestionsRequestedEventArgs> SuggestionsRequested;
+ }

+ public class Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs {
+   public string Language { get; }
+   public SearchQueryLinguisticDetails LinguisticDetails { get; }
+   public string QueryText { get; }
+ }

+ public class Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs {
+   public VirtualKeyModifiers KeyModifiers { get; }
+   public string Language { get; }
+   public SearchQueryLinguisticDetails LinguisticDetails { get; }
+   public string QueryText { get; }
+ }

+ public class Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs {
+   public VirtualKeyModifiers KeyModifiers { get; }
+   public string Tag { get; }
+   public SearchBoxResultSuggestionChosenEventArgs();
+ }

+ public class Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs {
+   public string Language { get; }
+   public SearchQueryLinguisticDetails LinguisticDetails { get; }
+   public string QueryText { get; }
+   public SearchSuggestionsRequest Request { get; }
+ }

+ public class Windows.UI.Xaml.Controls.SelectedDatesChangedEventArgs {
+   public IVectorView<DateTime> AddedDates { get; }
+   public IVectorView<DateTime> RemovedDates { get; }
+ }

+ public class Windows.UI.Xaml.Controls.SplitView : Windows.UI.Xaml.Controls.Control {
+   public SplitViewPanePlacement PanePlacement { get; set; }
+   public Brush PaneBackground { get; set; }
+   public UIElement Pane { get; set; }
+   public double OpenPaneLength { get; set; }
+   public bool IsPaneOpen { get; set; }
+   public SplitViewDisplayMode DisplayMode { get; set; }
+   public UIElement Content { get; set; }
+   public double CompactPaneLength { get; set; }
+   public SplitViewTemplateSettings TemplateSettings { get; }
+   public DependencyProperty CompactPaneLengthProperty { get; }
+   public DependencyProperty ContentProperty { get; }
+   public DependencyProperty DisplayModeProperty { get; }
+   public DependencyProperty IsPaneOpenProperty { get; }
+   public DependencyProperty OpenPaneLengthProperty { get; }
+   public DependencyProperty PaneBackgroundProperty { get; }
+   public DependencyProperty PanePlacementProperty { get; }
+   public DependencyProperty PaneProperty { get; }
+   public DependencyProperty TemplateSettingsProperty { get; }
+   public SplitView();
+   TypedEventHandler<SplitView, object> PaneClosed;
+   TypedEventHandler<SplitView, SplitViewPaneClosingEventArgs> PaneClosing;
+ }

+ public enum Windows.UI.Xaml.Controls.SplitViewDisplayMode {
+   Overlay = 0,
+   Inline = 1,
+   CompactOverlay = 2,
+   CompactInline = 3,
+ }

+ public class Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs {
+   public bool Cancel { get; set; }
+ }

+ public enum Windows.UI.Xaml.Controls.SplitViewPanePlacement {
+   Left = 0,
+   Right = 1,
+ }

+ public class Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs {
+   public int Length { get; }
+   public int StartIndex { get; }
+ }

+ public class Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs {
+   public int Length { get; }
+   public int StartIndex { get; }
+ }

+ public class Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs {
+   public int Length { get; }
+   public int StartIndex { get; }
+ }

+ public class Windows.UI.Xaml.Controls.ValidationIndicator : Windows.UI.Xaml.Controls.Control {
+   public Control Target { get; }
+   public ValidationIndicator();
+ }

| public class Windows.UI.Xaml.Controls.WebView : Windows.UI.Xaml.FrameworkElement {
+   public void AddWebAllowedObject( string name, object pObject );
| }

+ public class Windows.UI.Xaml.Controls.Primitives.CalendarPanel : Windows.UI.Xaml.Controls.Panel {
+   public CalendarPanel();
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings : Windows.UI.Xaml.DependencyObject {
+   public bool HasMoreContentAfter { get; }
+   public bool HasMoreContentBefore { get; }
+   public bool HasMoreViews { get; }
+   public string HeaderText { get; }
+   public double MinViewWidth { get; }
+   public string WeekDay1 { get; }
+   public string WeekDay2 { get; }
+   public string WeekDay3 { get; }
+   public string WeekDay4 { get; }
+   public string WeekDay5 { get; }
+   public string WeekDay6 { get; }
+   public string WeekDay7 { get; }
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.GridViewItemPresenter : Windows.UI.Xaml.Controls.ContentPresenter {
+   public double DisabledOpacity { get; set; }
+   public Thickness ContentMargin { get; set; }
+   public Brush CheckSelectingBrush { get; set; }
+   public Brush CheckHintBrush { get; set; }
+   public Brush CheckBrush { get; set; }
+   public Brush DragBackground { get; set; }
+   public Thickness Padding { get; set; }
+   public HorizontalAlignment HorizontalContentAlignment { get; set; }
+   public double DragOpacity { get; set; }
+   public Brush DragForeground { get; set; }
+   public Thickness SelectedBorderThickness { get; set; }
+   public VerticalAlignment VerticalContentAlignment { get; set; }
+   public bool SelectionCheckMarkVisualEnabled { get; set; }
+   public Brush SelectedPointerOverBorderBrush { get; set; }
+   public Brush SelectedPointerOverBackground { get; set; }
+   public Brush SelectedForeground { get; set; }
+   public Brush SelectedBackground { get; set; }
+   public double ReorderHintOffset { get; set; }
+   public Brush FocusBorderBrush { get; set; }
+   public Thickness PointerOverBackgroundMargin { get; set; }
+   public Brush PointerOverBackground { get; set; }
+   public Brush PlaceholderBackground { get; set; }
+   public DependencyProperty CheckBrushProperty { get; }
+   public DependencyProperty CheckHintBrushProperty { get; }
+   public DependencyProperty CheckSelectingBrushProperty { get; }
+   public DependencyProperty ContentMarginProperty { get; }
+   public DependencyProperty DisabledOpacityProperty { get; }
+   public DependencyProperty DragBackgroundProperty { get; }
+   public DependencyProperty DragForegroundProperty { get; }
+   public DependencyProperty DragOpacityProperty { get; }
+   public DependencyProperty FocusBorderBrushProperty { get; }
+   public DependencyProperty HorizontalContentAlignmentProperty { get; }
+   public DependencyProperty PaddingProperty { get; }
+   public DependencyProperty PlaceholderBackgroundProperty { get; }
+   public DependencyProperty PointerOverBackgroundMarginProperty { get; }
+   public DependencyProperty PointerOverBackgroundProperty { get; }
+   public DependencyProperty ReorderHintOffsetProperty { get; }
+   public DependencyProperty SelectedBackgroundProperty { get; }
+   public DependencyProperty SelectedBorderThicknessProperty { get; }
+   public DependencyProperty SelectedForegroundProperty { get; }
+   public DependencyProperty SelectedPointerOverBackgroundProperty { get; }
+   public DependencyProperty SelectedPointerOverBorderBrushProperty { get; }
+   public DependencyProperty SelectionCheckMarkVisualEnabledProperty { get; }
+   public DependencyProperty VerticalContentAlignmentProperty { get; }
+   public GridViewItemPresenter();
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.ListViewItemPresenter : Windows.UI.Xaml.Controls.ContentPresenter {
+   public double DisabledOpacity { get; set; }
+   public Thickness ContentMargin { get; set; }
+   public Brush CheckSelectingBrush { get; set; }
+   public Brush CheckHintBrush { get; set; }
+   public Brush CheckBrush { get; set; }
+   public Brush DragBackground { get; set; }
+   public Thickness Padding { get; set; }
+   public HorizontalAlignment HorizontalContentAlignment { get; set; }
+   public double DragOpacity { get; set; }
+   public Brush DragForeground { get; set; }
+   public Thickness SelectedBorderThickness { get; set; }
+   public VerticalAlignment VerticalContentAlignment { get; set; }
+   public bool SelectionCheckMarkVisualEnabled { get; set; }
+   public Brush SelectedPointerOverBorderBrush { get; set; }
+   public Brush SelectedPointerOverBackground { get; set; }
+   public Brush SelectedForeground { get; set; }
+   public Brush SelectedBackground { get; set; }
+   public double ReorderHintOffset { get; set; }
+   public Brush FocusBorderBrush { get; set; }
+   public Thickness PointerOverBackgroundMargin { get; set; }
+   public Brush PointerOverBackground { get; set; }
+   public Brush PlaceholderBackground { get; set; }
+   public DependencyProperty CheckBrushProperty { get; }
+   public DependencyProperty CheckHintBrushProperty { get; }
+   public DependencyProperty CheckSelectingBrushProperty { get; }
+   public DependencyProperty ContentMarginProperty { get; }
+   public DependencyProperty DisabledOpacityProperty { get; }
+   public DependencyProperty DragBackgroundProperty { get; }
+   public DependencyProperty DragForegroundProperty { get; }
+   public DependencyProperty DragOpacityProperty { get; }
+   public DependencyProperty FocusBorderBrushProperty { get; }
+   public DependencyProperty HorizontalContentAlignmentProperty { get; }
+   public DependencyProperty PaddingProperty { get; }
+   public DependencyProperty PlaceholderBackgroundProperty { get; }
+   public DependencyProperty PointerOverBackgroundMarginProperty { get; }
+   public DependencyProperty PointerOverBackgroundProperty { get; }
+   public DependencyProperty ReorderHintOffsetProperty { get; }
+   public DependencyProperty SelectedBackgroundProperty { get; }
+   public DependencyProperty SelectedBorderThicknessProperty { get; }
+   public DependencyProperty SelectedForegroundProperty { get; }
+   public DependencyProperty SelectedPointerOverBackgroundProperty { get; }
+   public DependencyProperty SelectedPointerOverBorderBrushProperty { get; }
+   public DependencyProperty SelectionCheckMarkVisualEnabledProperty { get; }
+   public DependencyProperty VerticalContentAlignmentProperty { get; }
+   public ListViewItemPresenter();
+ }

+ public class Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings : Windows.UI.Xaml.DependencyObject {
+   public GridLength CompactPaneGridLength { get; }
+   public double NegativeOpenPaneLength { get; }
+   public double NegativeOpenPaneLengthMinusCompactLength { get; }
+   public GridLength OpenPaneGridLength { get; }
+   public double OpenPaneLength { get; }
+   public double OpenPaneLengthMinusCompactLength { get; }
+ }

+ public interface Windows.UI.Xaml.Data.IItemsRangeInfo {
+   public void RangesChanged( ItemIndexRange visibleRange, IVectorView<ItemIndexRange> trackedItems );
+ }

+ public interface Windows.UI.Xaml.Data.IItemsRangeInfoFactory {
+   public IItemsRangeInfo CreateItemsRangeInfo();
+ }

+ public interface Windows.UI.Xaml.Data.ISelectionInfo {
+   public void SelectRange( ItemIndexRange itemIndexRange );
+   public void DeselectRange( ItemIndexRange itemIndexRange );
+   public bool IsSelected( int returnValue );
+   public IVectorView<ItemIndexRange> GetSelectedRanges();
+ }

+ public interface Windows.UI.Xaml.Data.ISelectionInfoFactory {
+   public ISelectionInfo CreateSelectionInfo();
+ }

+ public class Windows.UI.Xaml.Data.ItemIndexRange {
+   public int FirstIndex { get; }
+   public int LastIndex { get; }
+   public uint Length { get; }
+   public ItemIndexRange( int firstIndex, uint length );
+ }

| public class Windows.UI.Xaml.Documents.Glyphs : Windows.UI.Xaml.FrameworkElement {
+   public bool IsColorFontEnabled { get; set; }
+   public int ColorFontPaletteIndex { get; set; }
+   public DependencyProperty ColorFontPaletteIndexProperty { get; }
+   public DependencyProperty IsColorFontEnabledProperty { get; }
| }

| public class Windows.UI.Xaml.Input.FocusManager {
+   public static UIElement FindNextFocus( FocusNavigationDirection result );
+   public static UIElement FindNextFocus( FocusNavigationDirection result, Rect focusNavigationDirection );
| }

| public enum Windows.UI.Xaml.Input.FocusNavigationDirection {
+   Up = 2,
+   Down = 3,
+   Left = 4,
+   Right = 5,
+   None = 6,
| }

+ public class Windows.UI.Xaml.Input.GettingFocusEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public UIElement NewFocus { get; set; }
+   public bool Handled { get; set; }
+   public FocusNavigationDirection FocusNavigationDirection { get; }
+   public UIElement OldFocus { get; }
+ }

| public enum Windows.UI.Xaml.Input.InputScopeNameValue {
+   CurrencyAmount = 21,
+   DateMonthNumber = 23,
+   DateDayNumber = 24,
+   DateYear = 25,
+   Digits = 28,
+   Password = 31,
+   TelephoneCountryCode = 33,
+   TelephoneAreaCode = 34,
+   TelephoneLocalNumber = 35,
+   TimeHour = 37,
+   TimeMinutesOrSeconds = 38,
+   Text = 57,
+   EmailNameOrAddress = 60,
+   Maps = 62,
+   NumericPassword = 63,
+   NumericPin = 64,
+   AlphanumericPin = 65,
+   FormulaNumber = 67,
| }

+ public class Windows.UI.Xaml.Input.LosingFocusEventArgs : Windows.UI.Xaml.RoutedEventArgs {
+   public UIElement NewFocus { get; set; }
+   public bool Handled { get; set; }
+   public FocusNavigationDirection FocusNavigationDirection { get; }
+   public UIElement OldFocus { get; }
+ }

- public class Windows.UI.Xaml.Markup.XamlBinaryWriter;

- public struct Windows.UI.Xaml.Markup.XamlBinaryWriterErrorInformation;

+ public class Windows.UI.Xaml.Markup.XamlBindingHelper {
+   public static void SuspendRendering( UIElement target );
+   public static void ResumeRendering( UIElement target );
+ }

| public class Windows.UI.Xaml.Markup.XamlReader {
+   public static void EnsureElementRealized( IComponentConnector connector, int connectionId );
| }

+ public class Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs {
+   public FailedMediaStreamKind StreamKind { get; }
+   public PartialMediaFailureDetectedEventArgs();
+ }

+ public class Windows.UI.Xaml.Media.TimedTextCue {
+   public TimeSpan StartTime { get; set; }
+   public TimedTextTrackKind Kind { get; set; }
+   public int Id { get; set; }
+   public TimeSpan Duration { get; set; }
+   public TimedTextStyle CueStyle { get; set; }
+   public TimedTextRegion CueRegion { get; set; }
+   public IVector<TimedTextLine> Lines { get; }
+   public TimedTextCue();
+   public IBuffer GetData();
+ }

+ public class Windows.UI.Xaml.Media.TimedTextCueEventArgs {
+   public TimedTextCue Cue { get; }
+ }

+ public void delegate Windows.UI.Xaml.Media.TimedTextCueEventHandler( object sender, TimedTextCueEventArgs e );

+ public class Windows.UI.Xaml.Media.TimedTextErrorEventArgs {
+   public HResult Exception { get; }
+ }

+ public void delegate Windows.UI.Xaml.Media.TimedTextErrorEventHandler( object sender, TimedTextErrorEventArgs e );

+ public class Windows.UI.Xaml.Media.TimedTextLine {
+   public string Text { get; set; }
+   public IVector<TimedTextSubformat> Subformats { get; }
+   public TimedTextLine();
+ }

+ public class Windows.UI.Xaml.Media.TimedTextRegion {
+   public string Name { get; set; }
+   public TimedTextUnit LineHeightUnit { get; set; }
+   public double LineHeight { get; set; }
+   public bool IsOverflowClipped { get; set; }
+   public HorizontalAlignment HorizontalAlignment { get; set; }
+   public TimedTextUnit ExtentUnit { get; set; }
+   public Size Extent { get; set; }
+   public SolidColorBrush Background { get; set; }
+   public int ZIndex { get; set; }
+   public TimedTextWritingMode WritingMode { get; set; }
+   public TextWrapping TextWrapping { get; set; }
+   public TimedTextScrollMode ScrollMode { get; set; }
+   public TimedTextUnit PositionUnit { get; set; }
+   public Point Position { get; set; }
+   public TimedTextUnit PaddingUnit { get; set; }
+   public Thickness Padding { get; set; }
+   public TimedTextRegion();
+ }

+ public enum Windows.UI.Xaml.Media.TimedTextScrollMode {
+   PopOn = 0,
+   RollUp = 1,
+ }

+ public class Windows.UI.Xaml.Media.TimedTextStyle {
+   public HorizontalAlignment HorizontalAlignment { get; set; }
+   public FontWeight FontWeight { get; set; }
+   public FontFamily FontFamily { get; set; }
+   public FlowDirection FlowDirection { get; set; }
+   public SolidColorBrush Background { get; set; }
+   public double FontSize { get; set; }
+   public double OutlineRadius { get; set; }
+   public VerticalAlignment VerticalAlignment { get; set; }
+   public TimedTextUnit OutlineUnit { get; set; }
+   public Thickness OutlineThickness { get; set; }
+   public SolidColorBrush OutlineColor { get; set; }
+   public SolidColorBrush Foreground { get; set; }
+   public string Name { get; set; }
+   public bool IsBackgroundAlwaysShown { get; set; }
+   public TimedTextStyle();
+ }

+ public class Windows.UI.Xaml.Media.TimedTextSubformat {
+   public TimedTextStyle SubformatStyle { get; set; }
+   public int StartIndex { get; set; }
+   public int Length { get; set; }
+   public TimedTextSubformat();
+ }

+ public class Windows.UI.Xaml.Media.TimedTextTrack {
+   public Uri SourceUri { get; set; }
+   public string Language { get; set; }
+   public string Label { get; set; }
+   public TimedTextTrackKind Kind { get; set; }
+   public bool IsDefault { get; set; }
+   public int Id { get; set; }
+   public TimedTextTrack();
+ }

+ public enum Windows.UI.Xaml.Media.TimedTextTrackKind {
+   Caption = 0,
+   Subtitle = 1,
+   Metadata = 2,
+ }

+ public enum Windows.UI.Xaml.Media.TimedTextUnit {
+   Pixels = 0,
+   Percentage = 1,
+ }

+ public enum Windows.UI.Xaml.Media.TimedTextWritingMode {
+   LeftRightTopBottom = 0,
+   RightLeftTopBottom = 1,
+   TopBottomRightLeft = 2,
+   TopBottomLeftRight = 3,
+   LeftRight = 4,
+   RightLeft = 5,
+   TopBottom = 6,
+ }

+ public class Windows.UI.Xaml.Media.Media3D.CompositeTransform3D : Windows.UI.Xaml.Media.Media3D.Transform3D {
+   public double RotationZ { get; set; }
+   public double RotationY { get; set; }
+   public double RotationX { get; set; }
+   public double CenterZ { get; set; }
+   public double CenterY { get; set; }
+   public double CenterX { get; set; }
+   public double TranslateZ { get; set; }
+   public double TranslateY { get; set; }
+   public double TranslateX { get; set; }
+   public double ScaleZ { get; set; }
+   public double ScaleY { get; set; }
+   public double ScaleX { get; set; }
+   public DependencyProperty CenterXProperty { get; }
+   public DependencyProperty CenterYProperty { get; }
+   public DependencyProperty CenterZProperty { get; }
+   public DependencyProperty RotationXProperty { get; }
+   public DependencyProperty RotationYProperty { get; }
+   public DependencyProperty RotationZProperty { get; }
+   public DependencyProperty ScaleXProperty { get; }
+   public DependencyProperty ScaleYProperty { get; }
+   public DependencyProperty ScaleZProperty { get; }
+   public DependencyProperty TranslateXProperty { get; }
+   public DependencyProperty TranslateYProperty { get; }
+   public DependencyProperty TranslateZProperty { get; }
+   public CompositeTransform3D();
+ }

+ public class Windows.UI.Xaml.Media.Media3D.PerspectiveTransform3D : Windows.UI.Xaml.Media.Media3D.Transform3D {
+   public double OffsetY { get; set; }
+   public double OffsetX { get; set; }
+   public double Depth { get; set; }
+   public DependencyProperty DepthProperty { get; }
+   public DependencyProperty OffsetXProperty { get; }
+   public DependencyProperty OffsetYProperty { get; }
+   public PerspectiveTransform3D();
+ }

+ public class Windows.UI.Xaml.Media.Media3D.Transform3D : Windows.UI.Xaml.DependencyObject {
+   protected Transform3D();
+ }

+ public class Windows.UI.Xaml.Printing.AddPagesEventArgs {
+   public PrintTaskOptions PrintTaskOptions { get; }
+   public AddPagesEventArgs();
+ }

+ public void delegate Windows.UI.Xaml.Printing.AddPagesEventHandler( object sender, AddPagesEventArgs e );

+ public class Windows.UI.Xaml.Printing.GetPreviewPageEventArgs {
+   public int PageNumber { get; }
+   public GetPreviewPageEventArgs();
+ }

+ public void delegate Windows.UI.Xaml.Printing.GetPreviewPageEventHandler( object sender, GetPreviewPageEventArgs e );

+ public class Windows.UI.Xaml.Printing.PaginateEventArgs {
+   public int CurrentPreviewPageNumber { get; }
+   public PrintTaskOptions PrintTaskOptions { get; }
+   public PaginateEventArgs();
+ }

+ public void delegate Windows.UI.Xaml.Printing.PaginateEventHandler( object sender, PaginateEventArgs e );

+ public enum Windows.UI.Xaml.Printing.PreviewPageCountType {
+   Final = 0,
+   Intermediate = 1,
+ }

+ public class Windows.UI.Xaml.Printing.PrintDocument : Windows.UI.Xaml.DependencyObject {
+   public IPrintDocumentSource DocumentSource { get; }
+   public DependencyProperty DocumentSourceProperty { get; }
+   public PrintDocument();
+   public void AddPage( UIElement pageVisual );
+   public void AddPagesComplete();
+   public void SetPreviewPageCount( int count, PreviewPageCountType type );
+   public void SetPreviewPage( int pageNumber, UIElement pageVisual );
+   public void InvalidatePreview();
+   Windows.UI.Xaml.Printing.AddPagesEventHandler AddPages;
+   Windows.UI.Xaml.Printing.GetPreviewPageEventHandler GetPreviewPage;
+   Windows.UI.Xaml.Printing.PaginateEventHandler Paginate;
+ }

| public enum Windows.Web.Http.HttpVersion {
+   Http20 = 3,
| }

| public class Windows.Web.Http.Filters.HttpBaseProtocolFilter {
+   public HttpVersion MaxVersion { get; set; }
| }