09 Jul 2018

Windows 10 Tip: Get more out of reading online with Grammar Tools in Microsoft Edge

Author: Athima Chansanchai
Go to Source

Reading online is convenient, but did you know it can also help you get more out of books and articles? Microsoft Edge has built-in learning tools that make it easier to read EPUB books and websites in Reading view: Grammar Tools.

The Windows 10 April 2018 Update added Grammar Tools support that allow you to break words into syllables and highlight parts of speed, such as nouns, verbs and adjectives.

These tools can improve reading comprehension through increasing fluency for English language learners or readers of other languages, and they can also help build confidence for emerging readers learning to read at higher levels. Breaking words into syllables improves word recognition, while highlighting parts of speech supports reading instruction and can improve writing quality.

Click on the image below to see how to use Grammar Tools:

Screen capture shows cursor hovering over Grammar Tools icon, opening to toggle on syllables and parts of speech

When you’re in Reading view, open Grammar Tools to break words into syllables and highlight parts of speed, such as nouns, verbs and adjectives.

Want to know what else you can do? Check out more Windows 10 Tips.

Go to Source

Share this
06 Jul 2018

Announcing Windows 10 Insider Preview Build 17711

Author: Dona Sarkar
Go to Source

Hello Windows Insiders!

Today, we are releasing Windows 10 Insider Preview Build 17711 (RS5) to Windows Insiders in the Fast ring in addition to those who opted in to Skip Ahead.

What’s new in Build 17711

Microsoft Edge Improvements

Learning tools get richer: Under learning tools available on Reading View, you can now see additional themes. These let you choose the theme color which is best for your eyes.

Under learning tools available on Reading View, you can now see additional themes.

Along with highlighting Parts of speech you can now also change the color in which the Past of speech should be highlighted as well as turn on an indicator right over it. Making it much easier to identify the part of speech.

Line focus: Helps improve focus while reading an article by highlighting sets of one, three, or five lines.

Line focus helps improve focus while reading an article by highlighting sets of one, three, or five lines.

New consent box for saving Autofill data: Microsoft Edge seeks your permission each time to save your passwords and card details for Autofill purposes. We have come up with improved design and string changes to the consent notification pop-up to improve discoverability and provide clarity on the value of saving this information. The changes include introducing password and payment icons, improved messaging, and highlighting of options. One interesting update would be the cool micro-animations for the new password and payment icons.

Improved design and text for dialog for when Microsoft Edge seeks your permission each time to save your passwords and card details for Autofill purposes.

PDF toolbar improvements: PDF toolbar can now be invoked by just hovering at the top to make the tools easily accessible to the users.

Fluent Design Updates

At Build 2018 we shared our vision of the evolution of Fluent Design. We introduced acrylic to many of our default menus recently, and today to help improve user focus we’re bringing added depth in the form of shadows.

Shadows provide visual hierarchy, and with Build 17711 many of our default modern popup type controls will now have them. This is enabled on a smaller set of controls than what the general public will eventually see, and Insiders can expect to see the support grow in subsequent builds.

Microsoft Edge context menu now has a shadow.

Note: This is a work in progress and you may see some glitches or oddities – this will be improved across flights.

Display Improvements

A new Windows HD Color page is now available under Display Settings! Windows HD Color-capable devices can show high dynamic range (HDR) content, including photos, videos, games, and apps.  This depends on your display and your PC. The “Windows HD Color Settings” page linked in Display Settings now reports your system’s HD Color capabilities and allows HD Color features to be configured on capable systems. The HD Color settings page is your one-stop shop to understand and configure your device’s settings – if you have an HDR-capable display connected to a recent PC, please give it a try and send us feedback!

A new Windows HD Color page is now available under Display Settings! Windows HD Color-capable devices can show high dynamic range (HDR) content, including photos, videos, games, and apps.

Registry Editor Improvements

Have you ever been typing into the regedit address bar, and the next part of the path is just on the tip of your tongue, but you can’t remember? Starting with today’s build, you’ll now see a dropdown as you type to help complete the next part of the path! Oh, and you can also press Ctrl + Backspace to delete the last “word”, which makes backing up work that much faster (Ctrl + Delete will delete the next word).

Showing regedit with an autocomplete dropdown list.

General changes, improvements, and fixes for PC

  • REMINDER: Thank you for your continued support of testing Sets. We continue to receive valuable feedback from you as we develop this feature helping to ensure we deliver the best possible experience once it’s ready for release. Starting with this build, we’re taking Sets offline to continue making it great. Based on your feedback, some of the things we’re focusing on include improvements to the visual design and continuing to better integrate Office and Microsoft Edge into Sets to enhance workflow. If you have been testing Sets, you will no longer see it as of today’s build, however, Sets will return in a future WIP flight. Thanks again for your feedback.
  • We have fixed the issue that had regressed the time it takes to remotely deploy and debug a UWP application to a local virtual machine or an emulator.
  • We fixed an issue that could result in any surface that used reveal (including Start tiles and Settings categories) going totally white.
  • We fixed an issue resulting in some Insiders seeing a 0x80080005 error when upgrading to recent flights.
  • We fixed an issue where the “You are getting an update” dialog displayed unexpected extra characters.
  • We fixed an issue where aborting a shutdown would break input in UWP apps until rebooting.
  • We fixed an issue in recent flights where attempting to pin Settings categories to Start would either crash Settings or do nothing.
  • We fixed an issue resulting in Ethernet and Wi-Fi Settings unexpectedly missing content in the last flight.
  • We fixed a high hitting Settings crash impacting pages with Get Help content, including Touchpad Settings, Accounts Settings, and Family and Other Users Settings pages.
  • We fixed an issue that could result in Sign-In Settings being blank sometimes.
  • We fixed an issue where advanced keyboard settings might unexpectedly show “some settings are hidden by your org”.
  • We fixed an issue where creating a system image from backup and restore in control panel would fail on x86 machines.
  • We’ve decided to turn off the acrylic background in Task View – for now the design will return to how it shipped in the previous release, with acrylic cards instead. Thanks everyone who tried it out.
  • We fixed an issue where after using voice to ask Cortana certain questions you may not be able to ask her a second question with voice.
  • We fixed an issue that could result in explorer.exe crashing if certain apps were minimized when switching to tablet mode.
  • On the Share tab in File Explorer, we’ve updated the Remove access icon to be more modern. We’ve also made some tweaks to the Advanced security icon.
  • We fixed an issue that could result in the console forgetting the cursor color on upgrade and it getting set to 0x000000 (black). The fix will prevent future users from hitting this issue, but if you’ve already been impacted by this bug, you’ll need to manually fix the setting in the registry. To do this, open regedit.exe and delete the ‘CursorColor’ entry in ‘ComputerHKEY_CURRENT_USERConsole’ and any sub-keys, and re-launch your console window.
  • We addressed an issue where the audio driver would hang for many Bluetooth speakers and headsets which support the Hands-Free profile.
  • We fixed an issue resulting in the Microsoft Edge favorites pane scrolling sideways instead of up and down on mouse wheel in recent flights.
  • We fixed a few issues highly impacting Microsoft Edge reliability in the last few flights.
  • We fixed an issue resulting in Internet Explorer losing all settings and becoming unpinned from the taskbar with each of the last few flights.
  • We fixed an issue resulting in ethernet not working for some Insiders using Broadcom ethernet drivers on older hardware in the last flight.
  • We fixed an issue where remoting into a PC running the previous flight could result in just seeing a black window.
  • We fixed an issue that could result in certain games hanging when typing into the chat window.
  • We fixed an issue from the last flight where text predictions and shapewriting candidates wouldn’t appear in the touch keyboard’s candidate list until backspace is pressed while typing.
  • We fixed an issue where when Narrator started you would be presented with a dialog that informed the user of the change to Narrator’s keyboard layout and the dialog might not take focus or speak after Narrator has started.
  • We fixed an issue where when you changed Narrator’s default Narrator key to just caps lock the Insert key would continue to function until the caps lock key was used as the Narrator key or if the user restarts Narrator.
  • We fixed an issue where if your System > Display > Scaling and layout is not set to 100%, some text might appear smaller after reverting “Make text bigger” value back to 0%.
  • We fixed an issue where Windows Mixed Reality might get stuck after going to sleep and display a persistent error message in Mixed Reality Portal or a “Wake up” button that doesn’t work.

Known issues

  • We’re progressing in our work on adding dark theme in File Explorer and the Common File Dialog – you’ll notice improvements in this build, although we still have a few things left to do. You may see some unexpectedly light colors in these surfaces when in dark mode and/or dark on dark text.
  • In certain chases on PCs with multiple monitors, all the windows may appear shifted “up” and the mouse responds to the the wrong location. The workaround is use Ctrl + Alt + Del to bring up the task screen and then hit cancel. Repeat as necessary.
  • When you upgrade to this build you’ll find that the taskbar flyouts (network, volume, etc) no longer have an acrylic background.
  • We’re working on improving settings for HDR videos, games and apps in a new Windows HD Color page under System > Display. Some things temporarily will not work; notably, some users will not be able to enable/disable HDR display support.
  • Applications that use ICC color profiles may encounter errors such as Access Denied. This includes the Color Management control panel, and color profile switching on certain Surface devices.
  • When you use the Ease of Access Make Text bigger setting, you might see text clipping issues, or find that text is not increasing in size everywhere.
  • You may find your secondary displays don’t render correctly. Press Ctrl+Alt+Del and then cancel and that should resolve it.

Known issues for Developers

  • If you install any of the recent builds from the Fast ring and switch to the Slow ring – optional content such as enabling developer mode will fail. You will have to remain in the Fast ring to add/install/enable optional content. This is because optional content will only install on builds approved for specific rings.

Known issues for Narrator

  • We are aware of an issue causing Narrator speech to fade when waking from sleep mode. We are working on a fix.
  • When the Narrator Quickstart launches, Scan Mode may not reliably be on by default. We recommend going through the Quickstart with Scan Mode on. To verify that Scan Mode is on, press Caps Lock + Space.
  • When using Scan mode you may experience multiple stops for a single control. An example of this is if you have an image that is also a link. This is something we are actively working on.
  • If the Narrator key is set to just Insert and you attempt to send a Narrator command from a braille display then these commands will not function. As long as the Caps Lock key is a part of the Narrator key mapping then braille functionality will work as designed.
  • There is a known issue in automatic dialog reading where the title of the dialog is being spoken more than once.
  • The state of a Narrator command such as toggling Scan Mode on and off, volume up and down, voice speed, changing verbosity and context verbosity commands may not be announced when executed.

Known issues for Game bar

  • The framerate counter chart sometimes doesn’t show up correctly over known games.
  • The CPU chart shows an incorrect percentage of usage in the top left corner.
  • Charts in the performance panel don’t update immediately when clicking through tabs.
  • The user’s gamerpic doesn’t display correctly, even after signing in.

Bug Bash wrap up

Thanks again to all the Insiders who participated in our bug bash last week! Our next bug bash will be from July 27th to August 3rd – our last RS5 bug bash, and the last chance to participate in our contest  where you could win a chance to come visit Microsoft Headquarters. In the meantime, if you haven’t already, check out our special edition wallpaper collection  just for you.

Thanks again to all the Insiders who participated in our bug bash last week!

If you have any feedback about how this bug bash was run, please let us know !

No downtime for Hustle-As-A-Service,
Dona <3

Go to Source

Share this
06 Jul 2018

The Good, The Bad, and the Ugly of Mobility and BYOD

 

 
The Good, The Bad, and the Ugly of Mobility and BYOD
 
There are a lot of advantages to mobility in today’s workforce, but the Bring-Your-Own-Device (BYOD) movement has also brought its share of headaches as well.
 
We live in a society where everyone must have the newest technology. We are inundated with ads reminding us that the smartphone or tablet we just bought a year ago is laughably outdated and inferior to the upgrade that just hit the market.
 
People who have just bought the latest technology don’t want to have to set it aside to use a separate company-issued device. As a result, businesses are beginning to grant these employee-owned devices access to their file and email servers, databases, and applications.
 
While this brings certain competitive advantages to employers, it naturally carries many risks, too.
 
Let’s begin with the pros of BYOD…
 
The Advantages of BYOD
 
Greater Flexibility and Productivity – Personal devices allow workers more flexibility, which in turn can increase productivity. Today’s employee isn’t restricted to their office workstation or cubicle. They can carry out job responsibilities from home, a coffee shop, their child’s dance recital, or while traveling.
 
Reduced Costs – Purchasing even the most basic Blackberry for an employee can cost a company $900+ per worker. Costs like that can be completely eliminated by adopting a BYOD policy where employees are required to use their own device.
 
Happier Employees/Attractiveness to Job Seekers – Recent studies have found that 44% of job seekers are attracted more to employers who are open to BYOD and occasional remote work. Beyond this hiring advantage over competition, it has been found that employees as a whole are generally happier using the devices they own and prefer for work purposes.
 
Better Customer Service – This goes hand and hand with more flexibility and productivity. Mobility allows employees to occasionally resolve or escalate urgent client issues outside of normal working hours, and clients remember that kind of response time.
 
And now the cons of BYOD…
 
Disadvantages of BYOD
 
Compromised Data Security – Unfortunately, letting employees use their own smartphones, tablets, and laptops increases the likelihood of sensitive company or customer/client data being compromised. It is important for companies to establish a comprehensive mobile device security policy and never make any exceptions to it whatsoever. Really. No exceptions. Ever.
 
Employee Privacy – Many employees may oppose using their own devices for work, especially if it’s a company requirement that they aren’t reimbursed for. You have to remember that these are the same devices employees use to log into their Facebook and Twitter accounts or do their online banking. In this age of constant paranoia over big brother watching our every move, employees may be concerned that their employer will spy on them or access their personal passwords and information.
 
Handling Employee Turnover – Companies must consider how they will address the retrieval of company data and information from an employee’s device if the employee either quits or is fired. Some companies may require that employees only save or edit company files on their servers or use cloud-based sharing software like Dropbox to share and edit docs.
 
The Importance of a Mobile Device Management Tool
 
Obviously, businesses must keep track of all of the devices that access their server, applications, and data. Mobile Device Management helps enterprises centralize what is an otherwise chaotic hodgepodge of devices and operating systems. This ensures that all devices are configured, deployed, and properly monitored and managed. This is a smart way for businesses to embrace BYOD while securing data and applications across multiple devices.
 
Contact us at 

Share this
03 Jul 2018

Windows 10 SDK Preview Build 17704 available now!

Author: Clint Rutkas
Go to Source

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17704 or greater). The Preview SDK Build 17704 contains bug fixes and under development changes to the API surface area.

The Preview SDK can be downloaded from developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

Things to note:

  • This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 build 1803 or earlier to the Store.
  • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.
  • This build of the Windows SDK will only install on Windows 10 Insider Preview builds.

What’s New:

MSIX Support

It’s finally here! You can now package your applications as MSIX! These applications can be installed and run on any device with 17682 build or later.

To package your application with MSIX, use the MakeAppx tool. To install the application – just click on the MSIX file. To understand more about MSIX, watch this introductory video: link

Feedback and comments are welcome on our MSIX community: http://aka.ms/MSIXCommunity

MSIX is not currently supported by the App Certification Kit nor the Microsoft Store at this time.

MC.EXE

We’ve made some important changes to the C/C++ ETW code generation of mc.exe (Message Compiler):

The “-mof” parameter is deprecated. This parameter instructs MC.exe to generate ETW code that is compatible with Windows XP and earlier. Support for the “-mof” parameter will be removed in a future version of mc.exe.

As long as the “-mof” parameter is not used, the generated C/C++ header is now compatible with both kernel-mode and user-mode, regardless of whether “-km” or “-um” was specified on the command line. The header will use the _ETW_KM_ macro to automatically determine whether it is being compiled for kernel-mode or user-mode and will call the appropriate ETW APIs for each mode.

  • The only remaining difference between “-km” and “-um” is that the EventWrite[EventName] macros generated with “-km” have an Activity ID parameter while the EventWrite[EventName] macros generated with “-um” do not have an Activity ID parameter.

The EventWrite[EventName] macros now default to calling EventWriteTransfer (user mode) or EtwWriteTransfer (kernel mode). Previously, the EventWrite[EventName] macros defaulted to calling EventWrite (user mode) or EtwWrite (kernel mode).

The generated header now supports several customization macros. For example, you can set the MCGEN_EVENTWRITETRANSFER macro if you need the generated macros to call something other than EventWriteTransfer.

  • The manifest supports new attributes.
    • Event “name”: non-localized event name.
    • Event “attributes”: additional key-value metadata for an event such as filename, line number, component name, function name.
    • Event “tags”: 28-bit value with user-defined semantics (per-event).
    • Field “tags”: 28-bit value with user-defined semantics (per-field – can be applied to “data” or “struct” elements).
  • You can now define “provider traits” in the manifest (e.g. provider group). If provider traits are used in the manifest, the EventRegister[ProviderName] macro will automatically register them.
  • MC will now report an error if a localized message file is missing a string. (Previously MC would silently generate a corrupt message resource.)
  • MC can now generate Unicode (utf-8 or utf-16) output with the “-cp utf-8” or “-cp utf-16” parameters.

Known Issues:

The SDK headers are generated with types in the “ABI” namespace. This is done to avoid conflicts with C++/CX and C++/WinRT clients that need to consume types directly at the ABI layer[1]. By default, types emitted by MIDL are *not* put in the ABI namespace, however this has the potential to introduce conflicts from teams attempting to consume ABI types from Windows WinRT MIDL generated headers and non-Windows WinRT MIDL generated headers (this is especially challenging if the non-Windows header references Windows types).

To ensure that developers have a consistent view of the WinRT API surface, validation has been added to the generated headers to ensure that the ABI prefix is consistent between the Windows headers and user generated headers. If you encounter an error like:

5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): error C2220: warning treated as error – no ‘object’ file generated

5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): warning C4005: ‘CHECK_NS_PREFIX_STATE’: macro redefinition

5>g:(41): note: see previous definition of ‘CHECK_NS_PREFIX_STATE’

It means that some of your MIDL generated headers are inconsistent with the system generated headers.

There are two ways to fix this:

  • Preferred: Compile your IDL file with the /ns_prefix MIDL command line switch. This will cause all your types to be moved to the ABI namespace consistent with the Windows headers. This may require code changes in your code however.
  • Alternate: Add #define DISABLE_NS_PREFIX_CHECKS before including the Windows headers. This will suppress the validation.

API Spot Light:

Check out LauncherOptions.GroupingPreference.

 
namespace Windows.System {
  public sealed class FolderLauncherOptions : ILauncherViewOptions {
    ViewGrouping GroupingPreference { get; set; }
  }
  public sealed class LauncherOptions : ILauncherViewOptions {
    ViewGrouping GroupingPreference { get; set; }
  }

This release contains the new LauncherOptions.GroupingPreference property to assist your app in tailoring its behavior for Sets. Watch the presentation here.

API Updates, Additions and Removals

When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.

The following APIs have been added to the platform since the release of 17134. The APIs below have been removed.

Additions:


namespace Windows.AI.MachineLearning {
  public interface ILearningModelFeatureDescriptor
  public interface ILearningModelFeatureValue
  public interface ILearningModelOperatorProvider
  public sealed class ImageFeatureDescriptor : ILearningModelFeatureDescriptor
  public sealed class ImageFeatureValue : ILearningModelFeatureValue
  public interface ITensor : ILearningModelFeatureValue
  public sealed class LearningModel : IClosable
  public sealed class LearningModelBinding : IIterable&lt;IKeyValuePair&lt;string, object&gt;&gt;, IMapView&lt;string, object&gt;
  public sealed class LearningModelDevice
  public enum LearningModelDeviceKind
  public sealed class LearningModelEvaluationResult
  public enum LearningModelFeatureKind
  public sealed class LearningModelSession : IClosable
  public struct MachineLearningContract
  public sealed class MapFeatureDescriptor : ILearningModelFeatureDescriptor
  public sealed class SequenceFeatureDescriptor : ILearningModelFeatureDescriptor
  public sealed class TensorBoolean : ILearningModelFeatureValue, ITensor
  public sealed class TensorDouble : ILearningModelFeatureValue, ITensor
  public sealed class TensorFeatureDescriptor : ILearningModelFeatureDescriptor
  public sealed class TensorFloat : ILearningModelFeatureValue, ITensor
  public sealed class TensorFloat16Bit : ILearningModelFeatureValue, ITensor
  public sealed class TensorInt16Bit : ILearningModelFeatureValue, ITensor
  public sealed class TensorInt32Bit : ILearningModelFeatureValue, ITensor
  public sealed class TensorInt64Bit : ILearningModelFeatureValue, ITensor
  public sealed class TensorInt8Bit : ILearningModelFeatureValue, ITensor
  public enum TensorKind
  public sealed class TensorString : ILearningModelFeatureValue, ITensor
  public sealed class TensorUInt16Bit : ILearningModelFeatureValue, ITensor
  public sealed class TensorUInt32Bit : ILearningModelFeatureValue, ITensor
  public sealed class TensorUInt64Bit : ILearningModelFeatureValue, ITensor
  public sealed class TensorUInt8Bit : ILearningModelFeatureValue, ITensor
}
namespace Windows.AI.MachineLearning.Preview {
  public interface DummyInterfaceToFixBuildBreak
}
namespace Windows.ApplicationModel {
  public sealed class AppInstallerInfo
  public sealed class LimitedAccessFeatureRequestResult
  public static class LimitedAccessFeatures
  public enum LimitedAccessFeatureStatus
  public sealed class Package {
    IAsyncOperation&lt;PackageUpdateAvailabilityResult&gt; CheckUpdateAvailabilityAsync();
    AppInstallerInfo GetAppInstallerInfo();
  }
  public enum PackageUpdateAvailability
  public sealed class PackageUpdateAvailabilityResult
}
namespace Windows.ApplicationModel.Calls {
  public sealed class VoipCallCoordinator {
    IAsyncOperation&lt;VoipPhoneCallResourceReservationStatus&gt; ReserveCallResourcesAsync();
  }
}
namespace Windows.ApplicationModel.Chat {
  public static class ChatCapabilitiesManager {
    public static IAsyncOperation&lt;ChatCapabilities&gt; GetCachedCapabilitiesAsync(string address, string transportId);
    public static IAsyncOperation&lt;ChatCapabilities&gt; GetCapabilitiesFromNetworkAsync(string address, string transportId);
  }
  public static class RcsManager {
    public static event EventHandler&lt;object&gt; TransportListChanged;
  }
}
namespace Windows.ApplicationModel.ComponentUI {
  public sealed class ComponentAddedEventArgs
  public enum ComponentLaunchError
  public sealed class ComponentLaunchOptions
  public sealed class ComponentLaunchResults
  public sealed class ComponentManager
  public sealed class ComponentRemovedEventArgs
  public sealed class ComponentReparentResults
  public sealed class ComponentSite
  public enum ComponentState
  public sealed class ComponentStateEventArgs
  public sealed class InputSitePrototype
}
namespace Windows.ApplicationModel.DataTransfer {
  public static class Clipboard {
    public static event EventHandler&lt;ClipboardHistoryChangedEventArgs&gt; HistoryChanged;
    public static event EventHandler&lt;object&gt; HistoryEnabledChanged;
    public static event EventHandler&lt;object&gt; RoamingEnabledChanged;
    public static bool ClearHistory();
    public static bool DeleteItemFromHistory(ClipboardHistoryItem item);
    public static IAsyncOperation&lt;ClipboardHistoryItemsResult&gt; GetHistoryItemsAsync();
    public static bool IsHistoryEnabled();
    public static bool IsRoamingEnabled();
    public static bool SetContentWithOptions(DataPackage content, ClipboardContentOptions options);
    public static SetHistoryItemAsContentStatus SetHistoryItemAsContent(ClipboardHistoryItem item);
  }
  public sealed class ClipboardContentOptions
  public sealed class ClipboardHistoryChangedEventArgs
  public sealed class ClipboardHistoryItem
  public sealed class ClipboardHistoryItemsResult
  public enum ClipboardHistoryItemsResultStatus
  public sealed class DataPackagePropertySetView : IIterable&lt;IKeyValuePair&lt;string, object&gt;&gt;, IMapView&lt;string, object&gt; {
    bool IsFromRoamingClipboard { get; }
    string SourceDisplayName { get; }
  }
  public enum SetHistoryItemAsContentStatus
}
namespace Windows.ApplicationModel.Store.Preview {
  public enum DeliveryOptimizationDownloadMode
  public enum DeliveryOptimizationDownloadModeSource
  public sealed class DeliveryOptimizationSettings
  public static class StoreConfiguration {
    public static bool IsPinToDesktopSupported();
    public static bool IsPinToStartSupported();
    public static bool IsPinToTaskbarSupported();
    public static void PinToDesktop(string appPackageFamilyName);
    public static void PinToDesktopForUser(User user, string appPackageFamilyName);
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public enum AppInstallationToastNotificationMode
  public sealed class AppInstallItem {
    AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
    AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
    bool PinToDesktopAfterInstall { get; set; }
    bool PinToStartAfterInstall { get; set; }
    bool PinToTaskbarAfterInstall { get; set; }
  }
  public sealed class AppInstallManager {
    bool CanInstallForAllUsers { get; }
  }
  public sealed class AppInstallOptions {
    string CampaignId { get; set; }
    AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
    string ExtendedCampaignId { get; set; }
    bool InstallForAllUsers { get; set; }
    AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
    bool PinToDesktopAfterInstall { get; set; }
    bool PinToStartAfterInstall { get; set; }
    bool PinToTaskbarAfterInstall { get; set; }
    bool StageButDoNotInstall { get; set; }
  }
  public sealed class AppUpdateOptions {
    bool AutomaticallyDownloadAndInstallUpdateIfFound { get; set; }
  }
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity {
    bool IsRoamable { get; set; }
  }
}
namespace Windows.Data.Text {
  public sealed class TextPredictionGenerator {
    CoreTextInputScope InputScope { get; set; }
    IAsyncOperation&lt;IVectorView&lt;string&gt;&gt; GetCandidatesAsync(string input, uint maxCandidates, TextPredictionOptions predictionOptions, IIterable&lt;string&gt; previousStrings);
    IAsyncOperation&lt;IVectorView&lt;string&gt;&gt; GetNextWordCandidatesAsync(uint maxCandidates, IIterable&lt;string&gt; previousStrings);
  }
  public enum TextPredictionOptions : uint
}
namespace Windows.Devices.Display.Core {
  public sealed class DisplayAdapter
  public enum DisplayBitsPerChannel : uint
  public sealed class DisplayDevice
  public enum DisplayDeviceCapability
  public sealed class DisplayFence
  public sealed class DisplayManager : IClosable
  public sealed class DisplayManagerChangedEventArgs
  public sealed class DisplayManagerDisabledEventArgs
  public sealed class DisplayManagerEnabledEventArgs
  public enum DisplayManagerOptions : uint
  public sealed class DisplayManagerPathsFailedOrInvalidatedEventArgs
  public enum DisplayManagerResult
  public sealed class DisplayManagerResultWithState
  public sealed class DisplayModeInfo
  public enum DisplayModeQueryOptions : uint
  public sealed class DisplayPath
  public enum DisplayPathScaling
  public enum DisplayPathStatus
  public struct DisplayPresentationRate
  public sealed class DisplayPrimaryDescription
  public enum DisplayRotation
  public sealed class DisplayScanout
 public sealed class DisplaySource
  public sealed class DisplayState
  public enum DisplayStateApplyOptions : uint
  public enum DisplayStateFunctionalizeOptions : uint
  public sealed class DisplayStateOperationResult
  public enum DisplayStateOperationStatus
  public sealed class DisplaySurface
  public sealed class DisplayTarget
  public enum DisplayTargetPersistence
  public sealed class DisplayTask
  public sealed class DisplayTaskPool
  public enum DisplayTaskSignalKind
  public sealed class DisplayView
  public sealed class DisplayWireFormat
  public enum DisplayWireFormatColorSpace
  public enum DisplayWireFormatEotf
  public enum DisplayWireFormatHdrMetadata
  public enum DisplayWireFormatPixelEncoding
}
namespace Windows.Devices.Enumeration {
  public enum DeviceInformationKind {
    DevicePanel = 8,
  }
  public sealed class DeviceInformationPairing {
    public static bool TryRegisterForAllInboundPairingRequestsWithProtectionLevel(DevicePairingKinds pairingKindsSupported, DevicePairingProtectionLevel minProtectionLevel);
  }
}
namespace Windows.Devices.Enumeration.Pnp {
  public enum PnpObjectType {
    DevicePanel = 8,
  }
}
namespace Windows.Devices.Lights {
  public sealed class LampArray
  public enum LampArrayKind
  public sealed class LampInfo
  public enum LampPurposes : uint
}
namespace Windows.Devices.Lights.Effects {
  public interface ILampArrayEffect
  public sealed class LampArrayBitmapEffect : ILampArrayEffect
  public sealed class LampArrayBitmapRequestedEventArgs
  public sealed class LampArrayBlinkEffect : ILampArrayEffect
  public sealed class LampArrayColorRampEffect : ILampArrayEffect
  public sealed class LampArrayCustomEffect : ILampArrayEffect
  public enum LampArrayEffectCompletionBehavior
  public sealed class LampArrayEffectPlaylist : IIterable&lt;ILampArrayEffect&gt;, IVectorView&lt;ILampArrayEffect&gt;
  public enum LampArrayEffectStartMode
  public enum LampArrayRepetitionMode
  public sealed class LampArraySolidEffect : ILampArrayEffect
  public sealed class LampArrayUpdateRequestedEventArgs
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScannerCapabilities {
    bool IsVideoPreviewSupported { get; }
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    event TypedEventHandler&lt;ClaimedBarcodeScanner, ClaimedBarcodeScannerClosedEventArgs&gt; Closed;
  }
  public sealed class ClaimedBarcodeScannerClosedEventArgs
  public sealed class ClaimedCashDrawer : IClosable {
    event TypedEventHandler&lt;ClaimedCashDrawer, ClaimedCashDrawerClosedEventArgs&gt; Closed;
  }
  public sealed class ClaimedCashDrawerClosedEventArgs
  public sealed class ClaimedLineDisplay : IClosable {
    event TypedEventHandler&lt;ClaimedLineDisplay, ClaimedLineDisplayClosedEventArgs&gt; Closed;
  }
  public sealed class ClaimedLineDisplayClosedEventArgs
  public sealed class ClaimedMagneticStripeReader : IClosable {
    event TypedEventHandler&lt;ClaimedMagneticStripeReader, ClaimedMagneticStripeReaderClosedEventArgs&gt; Closed;
  }
  public sealed class ClaimedMagneticStripeReaderClosedEventArgs
  public sealed class ClaimedPosPrinter : IClosable {
    event TypedEventHandler&lt;ClaimedPosPrinter, ClaimedPosPrinterClosedEventArgs&gt; Closed;
  }
  public sealed class ClaimedPosPrinterClosedEventArgs
}
namespace Windows.Devices.PointOfService.Provider {
  public sealed class BarcodeScannerDisableScannerRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerEnableScannerRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerFrameReader : IClosable
  public sealed class BarcodeScannerFrameReaderFrameArrivedEventArgs
  public sealed class BarcodeScannerGetSymbologyAttributesRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerHideVideoPreviewRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerProviderConnection : IClosable {
    IAsyncOperation&lt;BarcodeScannerFrameReader&gt; CreateFrameReaderAsync();
    IAsyncOperation&lt;BarcodeScannerFrameReader&gt; CreateFrameReaderAsync(BitmapPixelFormat preferredFormat);
    IAsyncOperation&lt;BarcodeScannerFrameReader&gt; CreateFrameReaderAsync(BitmapPixelFormat preferredFormat, BitmapSize preferredSize);
  }
  public sealed class BarcodeScannerSetActiveSymbologiesRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerSetSymbologyAttributesRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerStartSoftwareTriggerRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerStopSoftwareTriggerRequest {
    IAsyncAction ReportFailedAsync(int reason);
    IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
  }
  public sealed class BarcodeScannerVideoFrame : IClosable
}
namespace Windows.Devices.Sensors {
  public sealed class HingeAngleReading
  public sealed class HingeAngleSensor
  public sealed class HingeAngleSensorReadingChangedEventArgs
  public sealed class SimpleOrientationSensor {
    public static IAsyncOperation&lt;SimpleOrientationSensor&gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
}
namespace Windows.Devices.SmartCards {
  public static class KnownSmartCardAppletIds
  public sealed class SmartCardAppletIdGroup {
    string Description { get; set; }
    IRandomAccessStreamReference Logo { get; set; }
    ValueSet Properties { get; }
    bool SecureUserAuthenticationRequired { get; set; }
  }
  public sealed class SmartCardAppletIdGroupRegistration {
    string SmartCardReaderId { get; }
    IAsyncAction SetPropertiesAsync(ValueSet props);
  }
}
namespace Windows.Devices.WiFi {
  public enum WiFiPhyKind {
    HE = 10,
  }
}
namespace Windows.Globalization {
  public static class CurrencyIdentifiers {
    public static string MRU { get; }
    public static string SSP { get; }
    public static string STN { get; }
    public static string VES { get; }
  }
}
namespace Windows.Graphics.Capture {
  public sealed class Direct3D11CaptureFramePool : IClosable {
    public static Direct3D11CaptureFramePool CreateFreeThreaded(IDirect3DDevice device, DirectXPixelFormat pixelFormat, int numberOfBuffers, SizeInt32 size);
  }
  public sealed class GraphicsCaptureItem {
    public static GraphicsCaptureItem CreateFromVisual(Visual visual);
  }
}
namespace Windows.Graphics.Display.Core {
  public enum HdmiDisplayHdrOption {
    DolbyVisionLowLatency = 3,
  }
  public sealed class HdmiDisplayMode {
    bool IsDolbyVisionLowLatencySupported { get; }
  }
}
namespace Windows.Graphics.Imaging {
  public sealed class BitmapDecoder : IBitmapFrame, IBitmapFrameWithSoftwareBitmap {
    public static Guid HeifDecoderId { get; }
    public static Guid WebpDecoderId { get; }
  }
  public sealed class BitmapEncoder {
    public static Guid HeifEncoderId { get; }
  }
}
namespace Windows.Management.Deployment {
  public enum DeploymentOptions : uint {
    ForceUpdateFromAnyVersion = (uint)262144,
  }
  public sealed class PackageManager {
    IAsyncOperationWithProgress&lt;DeploymentResult, DeploymentProgress&gt; DeprovisionPackageForAllUsersAsync(string packageFamilyName);
  }
  public enum RemovalOptions : uint {
    RemoveForAllUsers = (uint)524288,
  }
}
namespace Windows.Management.Policies {
  public static class NamedPolicy {
    public static IAsyncAction ClearAllPoliciesAsync();
    public static IAsyncAction ClearAllPoliciesAsync(string accountId);
    public static NamedPolicySetter TryCreatePolicySetter(string accountId);
    public static NamedPolicySetter TryCreatePolicySetterForUser(User user, string accountId);
  }
  public sealed class NamedPolicySetter
}
namespace Windows.Media.Audio {
  public sealed class CreateAudioDeviceInputNodeResult {
    HResult ExtendedError { get; }
  }
  public sealed class CreateAudioDeviceOutputNodeResult {
    HResult ExtendedError { get; }
  }
  public sealed class CreateAudioFileInputNodeResult {
    HResult ExtendedError { get; }
  }
  public sealed class CreateAudioFileOutputNodeResult {
    HResult ExtendedError { get; }
  }
  public sealed class CreateAudioGraphResult {
    HResult ExtendedError { get; }
  }
  public sealed class CreateMediaSourceAudioInputNodeResult {
    HResult ExtendedError { get; }
  }
  public enum MixedRealitySpatialAudioFormatPolicy
  public sealed class SetDefaultSpatialAudioFormatResult
  public enum SetDefaultSpatialAudioFormatStatus
  public sealed class SpatialAudioDeviceConfiguration
  public sealed class SpatialAudioFormatConfiguration
  public static class SpatialAudioFormatSubtype
}
namespace Windows.Media.Control {
  public sealed class CurrentSessionChangedEventArgs
  public sealed class GlobalSystemMediaTransportControlsSession
  public sealed class GlobalSystemMediaTransportControlsSessionManager
  public sealed class GlobalSystemMediaTransportControlsSessionMediaProperties
  public sealed class GlobalSystemMediaTransportControlsSessionPlaybackControls
  public sealed class GlobalSystemMediaTransportControlsSessionPlaybackInfo
  public enum GlobalSystemMediaTransportControlsSessionPlaybackStatus
  public sealed class GlobalSystemMediaTransportControlsSessionTimelineProperties
  public sealed class MediaPropertiesChangedEventArgs
  public sealed class PlaybackInfoChangedEventArgs
  public sealed class SessionsChangedEventArgs
  public sealed class TimelinePropertiesChangedEventArgs
}
namespace Windows.Media.Core {
  public sealed class MediaStreamSample {
    IDirect3DSurface Direct3D11Surface { get; }
    public static MediaStreamSample CreateFromDirect3D11Surface(IDirect3DSurface surface, TimeSpan timestamp);
  }
}
namespace Windows.Media.Devices {
  public enum AudioRoutingPolicy
  public static class SystemAudioDeviceRoutingManager
  public sealed class SystemAudioDeviceRoutingSession : IClosable
}
namespace Windows.Media.Devices.Core {
  public sealed class CameraIntrinsics {
    public CameraIntrinsics(Vector2 focalLength, Vector2 principalPoint, Vector3 radialDistortion, Vector2 tangentialDistortion, uint imageWidth, uint imageHeight);
  }
}
namespace Windows.Media.Import {
  public enum PhotoImportContentTypeFilter {
    ImagesAndVideosFromCameraRoll = 3,
  }
  public sealed class PhotoImportItem {
    string Path { get; }
  }
}
namespace Windows.Media.MediaProperties {
  public sealed class ImageEncodingProperties : IMediaEncodingProperties {
    public static ImageEncodingProperties CreateHeif();
  }
  public static class MediaEncodingSubtypes {
    public static string Heif { get; }
  }
}
namespace Windows.Media.Protection.PlayReady {
  public static class PlayReadyStatics {
    public static IReference&lt;DateTime&gt; HardwareDRMDisabledAtTime { get; }
    public static IReference&lt;DateTime&gt; HardwareDRMDisabledUntilTime { get; }
    public static void ResetHardwareDRMDisabled();
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public enum AdaptiveMediaSourceResourceType {
    MediaSegmentIndex = 5,
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public enum BackgroundTransferPriority {
    Low = 2,
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class ConnectionProfile {
    bool CanDelete { get; }
    IAsyncOperation&lt;ConnectionProfileDeleteStatus&gt; TryDeleteAsync();
  }
  public enum ConnectionProfileDeleteStatus
}
namespace Windows.Networking.NetworkOperators {
  public enum ESimOperationStatus {
    CardGeneralFailure = 13,
    ConfirmationCodeMissing = 14,
    EidMismatch = 18,
    InvalidMatchingId = 15,
    NoCorrespondingRequest = 23,
    NoEligibleProfileForThisDevice = 16,
    OperationAborted = 17,
    OperationProhibitedByProfileClass = 21,
    ProfileNotAvailableForNewBinding = 19,
    ProfileNotPresent = 22,
    ProfileNotReleasedByOperator = 20,
  }
}
namespace Windows.Perception {
  public sealed class PerceptionTimestamp {
    TimeSpan SystemRelativeTargetTime { get; }
  }
  public static class PerceptionTimestampHelper {
    public static PerceptionTimestamp FromSystemRelativeTargetTime(TimeSpan targetTime);
 }
}
namespace Windows.Perception.Spatial {
  public sealed class SpatialAnchorExporter
  public enum SpatialAnchorExportPurpose
  public sealed class SpatialAnchorExportSufficiency
  public sealed class SpatialLocation {
    Vector3 AbsoluteAngularAccelerationAxisAngle { get; }
    Vector3 AbsoluteAngularVelocityAxisAngle { get; }
  }
}
namespace Windows.Perception.Spatial.Preview {
  public static class SpatialGraphInteropPreview
}
namespace Windows.Security.DataProtection {
  public enum UserDataAvailability
  public sealed class UserDataAvailabilityStateChangedEventArgs
  public sealed class UserDataBufferUnprotectResult
  public enum UserDataBufferUnprotectStatus
  public sealed class UserDataProtectionManager
  public sealed class UserDataStorageItemProtectionInfo
  public enum UserDataStorageItemProtectionStatus
}
namespace Windows.Services.Cortana {
  public sealed class CortanaActionableInsights
  public sealed class CortanaActionableInsightsOptions
}
namespace Windows.Services.Store {
  public sealed class StoreAppLicense {
    bool IsDiscLicense { get; }
  }
  public sealed class StoreContext {
    IAsyncOperation&lt;StoreRateAndReviewResult&gt; RequestRateAndReviewAppAsync();
    IAsyncOperation&lt;IVectorView&lt;StoreQueueItem&gt;&gt; SetInstallOrderForAssociatedStoreQueueItemsAsync(IIterable&lt;StoreQueueItem&gt; items);
  }
  public sealed class StoreQueueItem {
    IAsyncAction CancelInstallAsync();
    IAsyncAction PauseInstallAsync();
    IAsyncAction ResumeInstallAsync();
  }
  public sealed class StoreRateAndReviewResult
  public enum StoreRateAndReviewStatus
}
namespace Windows.Storage.Provider {
  public enum StorageProviderHydrationPolicyModifier : uint {
    AutoDehydrationAllowed = (uint)4,
  }
  public sealed class StorageProviderSyncRootInfo {
    Guid ProviderId { get; set; }
  }
}
namespace Windows.System {
  public sealed class AppUriHandlerHost
  public sealed class AppUriHandlerRegistration
  public sealed class AppUriHandlerRegistrationManager
  public sealed class FolderLauncherOptions : ILauncherViewOptions {
    ViewGrouping GroupingPreference { get; set; }
  }
  public static class Launcher {
    public static IAsyncOperation&lt;bool&gt; LaunchFolderPathAsync(string path);
    public static IAsyncOperation&lt;bool&gt; LaunchFolderPathAsync(string path, FolderLauncherOptions options);
    public static IAsyncOperation&lt;bool&gt; LaunchFolderPathForUserAsync(User user, string path);
    public static IAsyncOperation&lt;bool&gt; LaunchFolderPathForUserAsync(User user, string path, FolderLauncherOptions options);
  }
  public sealed class LauncherOptions : ILauncherViewOptions {
    ViewGrouping GroupingPreference { get; set; }
  }
}
namespace Windows.System.Preview {
  public enum HingeState
  public sealed class TwoPanelHingedDevicePosturePreview
  public sealed class TwoPanelHingedDevicePosturePreviewReading
  public sealed class TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs
}
namespace Windows.System.Profile {
  public enum SystemOutOfBoxExperienceState
  public static class SystemSetupInfo
  public static class WindowsIntegrityPolicy
}
namespace Windows.System.Profile.SystemManufacturers {
  public sealed class SystemSupportDeviceInfo
  public static class SystemSupportInfo {
    public static SystemSupportDeviceInfo LocalDeviceInfo { get; }
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    IVectorView&lt;RemoteSystemApp&gt; Apps { get; }
  }
  public sealed class RemoteSystemApp
  public sealed class RemoteSystemAppRegistration
  public sealed class RemoteSystemConnectionInfo
  public sealed class RemoteSystemConnectionRequest {
    RemoteSystemApp RemoteSystemApp { get; }
    public static RemoteSystemConnectionRequest CreateForApp(RemoteSystemApp remoteSystemApp);
  }
  public sealed class RemoteSystemWebAccountFilter : IRemoteSystemFilter
}
namespace Windows.System.Update {
  public enum SystemUpdateAttentionRequiredReason
  public sealed class SystemUpdateItem
  public enum SystemUpdateItemState
  public sealed class SystemUpdateLastErrorInfo
  public static class SystemUpdateManager
  public enum SystemUpdateManagerState
  public enum SystemUpdateStartInstallAction
}
namespace Windows.System.UserProfile {
  public sealed class AssignedAccessSettings
}
namespace Windows.UI.Accessibility {
  public sealed class ScreenReaderPositionChangedEventArgs
  public sealed class ScreenReaderService
}
namespace Windows.UI.Composition {
  public enum AnimationPropertyAccessMode
  public sealed class AnimationPropertyInfo : CompositionObject
  public sealed class BooleanKeyFrameAnimation : KeyFrameAnimation
  public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
    void SetAnimatableReferenceParameter(string parameterName, IAnimationObject source);
  }
  public enum CompositionBatchTypes : uint {
    AllAnimations = (uint)5,
    InfiniteAnimation = (uint)4,
  }
  public sealed class CompositionGeometricClip : CompositionClip
  public class CompositionGradientBrush : CompositionBrush {
    CompositionMappingMode MappingMode { get; set; }
  }
  public enum CompositionMappingMode
  public class CompositionObject : IAnimationObject, IClosable {
    void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
    public static void StartAnimationGroupWithIAnimationObject(IAnimationObject target, ICompositionAnimationBase animation);
    public static void StartAnimationWithIAnimationObject(IAnimationObject target, string propertyName, CompositionAnimation animation);
  }
  public sealed class Compositor : IClosable {
    BooleanKeyFrameAnimation CreateBooleanKeyFrameAnimation();
    CompositionGeometricClip CreateGeometricClip();
    CompositionGeometricClip CreateGeometricClip(CompositionGeometry geometry);
    RedirectVisual CreateRedirectVisual();
    RedirectVisual CreateRedirectVisualWithSourceVisual(Visual source);
  }
  public interface IAnimationObject
  public sealed class RedirectVisual : ContainerVisual
}
namespace Windows.UI.Composition.Interactions {
  public sealed class InteractionSourceConfiguration : CompositionObject
  public enum InteractionSourceRedirectionMode
  public sealed class InteractionTracker : CompositionObject {
    bool IsInertiaFromImpulse { get; }
    int TryUpdatePosition(Vector3 value, InteractionTrackerClampingOption option);
    int TryUpdatePositionBy(Vector3 amount, InteractionTrackerClampingOption option);
  }
  public enum InteractionTrackerClampingOption
  public sealed class InteractionTrackerInertiaStateEnteredArgs {
    bool IsInertiaFromImpulse { get; }
  }
  public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
    InteractionSourceConfiguration PointerWheelConfig { get; }
  }
}
namespace Windows.UI.Input.Inking.Preview {
  public sealed class PalmRejectionDelayZonePreview : IClosable
}
namespace Windows.UI.Notifications {
  public sealed class ScheduledToastNotificationShowingEventArgs
  public sealed class ToastNotifier {
    event TypedEventHandler&lt;ToastNotifier, ScheduledToastNotificationShowingEventArgs&gt; ScheduledToastNotificationShowing;
  }
}
namespace Windows.UI.Shell {
  public enum SecurityAppKind
  public sealed class SecurityAppManager
  public struct SecurityAppManagerContract
  public enum SecurityAppState
  public enum SecurityAppSubstatus
  public sealed class TaskbarManager {
    IAsyncOperation&lt;bool&gt; IsSecondaryTilePinnedAsync(string tileId);
    IAsyncOperation&lt;bool&gt; RequestPinSecondaryTileAsync(SecondaryTile secondaryTile);
    IAsyncOperation&lt;bool&gt; TryUnpinSecondaryTileAsync(string tileId);
  }
}
namespace Windows.UI.StartScreen {
  public sealed class StartScreenManager {
    IAsyncOperation&lt;bool&gt; ContainsSecondaryTileAsync(string tileId);
    IAsyncOperation&lt;bool&gt; TryRemoveSecondaryTileAsync(string tileId);
  }
}
namespace Windows.UI.Text {
  public sealed class RichEditTextDocument : ITextDocument {
    void ClearUndoRedoHistory();
  }
}
namespace Windows.UI.Text.Core {
  public sealed class CoreTextLayoutRequest {
    CoreTextLayoutBounds LayoutBoundsVisualPixels { get; }
  }
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationView {
    bool CanOpenInNewTab { get; }
    bool IsTabGroupingSupported { get; }
  }
  public sealed class ApplicationViewTitleBar {
    void SetActiveIconStreamAsync(RandomAccessStreamReference activeIcon);
  }
  public enum ApplicationViewWindowingMode {
    CompactOverlay = 3,
    Maximized = 4,
  }
  public interface ISystemTray
  public interface ISystemTrayStatics
  public sealed class SystemTray : ISystemTray
  public enum ViewGrouping
  public sealed class ViewModePreferences {
    ViewGrouping GroupingPreference { get; set; }
  }
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView {
    bool TryHide();
    bool TryShow();
    bool TryShow(CoreInputViewKind type);
  }
  public enum CoreInputViewKind
}
namespace Windows.UI.WebUI {
  public sealed class BackgroundActivatedEventArgs : IBackgroundActivatedEventArgs
  public delegate void BackgroundActivatedEventHandler(object sender, IBackgroundActivatedEventArgs eventArgs);
  public sealed class NewWebUIViewCreatedEventArgs
  public static class WebUIApplication {
    public static event BackgroundActivatedEventHandler BackgroundActivated;
    public static event EventHandler&lt;NewWebUIViewCreatedEventArgs&gt; NewWebUIViewCreated;
  }
  public sealed class WebUIView : IWebViewControl, IWebViewControl2
}
namespace Windows.UI.Xaml {
  public class BrushTransition
  public class ColorPaletteResources : ResourceDictionary
  public class DataTemplate : FrameworkTemplate, IElementFactory {
    UIElement GetElement(ElementFactoryGetArgs args);
    void RecycleElement(ElementFactoryRecycleArgs args);
  }
  public sealed class DebugSettings {
    bool FailFastOnErrors { get; set; }
  }
  public sealed class EffectiveViewportChangedEventArgs
  public sealed class ElementFactoryGetArgs
  public sealed class ElementFactoryRecycleArgs
  public class FrameworkElement : UIElement {
    bool IsLoaded { get; }
    event TypedEventHandler&lt;FrameworkElement, EffectiveViewportChangedEventArgs&gt; EffectiveViewportChanged;
    void InvalidateViewport();
  }
  public interface IElementFactory
  public class ScalarTransition
  public class UIElement : DependencyObject, IAnimationObject {
    bool CanBeScrollAnchor { get; set; }
    public static DependencyProperty CanBeScrollAnchorProperty { get; }
    Vector3 CenterPoint { get; set; }
    ScalarTransition OpacityTransition { get; set; }
    float Rotation { get; set; }
    Vector3 RotationAxis { get; set; }
    ScalarTransition RotationTransition { get; set; }
    Vector3 Scale { get; set; }
    Vector3Transition ScaleTransition { get; set; }
    Shadow Shadow { get; set; }
    public static DependencyProperty ShadowProperty { get; }
    Matrix4x4 TransformMatrix { get; set; }
    Vector3 Translation { get; set; }
    Vector3Transition TranslationTransition { get; set; }
    void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
    virtual void PopulatePropertyInfoOverride(string propertyName, AnimationPropertyInfo animationPropertyInfo);
    void StartAnimation(ICompositionAnimationBase animation);
    void StopAnimation(ICompositionAnimationBase animation);
  }
  public sealed class UIElementWeakCollection : IIterable&lt;UIElement&gt;, IVector&lt;UIElement&gt;
  public class Vector3Transition
  public enum Vector3TransitionComponents : uint
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty IsDialogProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty IsDialogProperty { get; }
    public static bool GetIsDialog(DependencyObject element);
    public static void SetIsDialog(DependencyObject element, bool value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public class AppBarButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider {
    ExpandCollapseState ExpandCollapseState { get; }
    void Collapse();
    void Expand();
  }
  public class AutomationPeer : DependencyObject {
    bool IsDialog();
    virtual bool IsDialogCore();
  }
  public class MenuBarAutomationPeer : FrameworkElementAutomationPeer
  public class MenuBarItemAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
}
namespace Windows.UI.Xaml.Controls {
  public sealed class AnchorRequestedEventArgs
  public class AppBarElementContainer : ContentControl, ICommandBarElement, ICommandBarElement2
  public sealed class AutoSuggestBox : ItemsControl, IInputValidationControl, IInputValidationControl2 {
    object Description { get; set; }
    public static DependencyProperty DescriptionProperty { get; }
    DataTemplate ErrorTemplate { get; set; }
    public static DependencyProperty ErrorTemplateProperty { get; }
    bool HasValidationErrors { get; }
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
    InputValidationKind InputValidationKind { get; set; }
    public static DependencyProperty InputValidationKindProperty { get; }
    InputValidationMode InputValidationMode { get; set; }
    public static DependencyProperty InputValidationModeProperty { get; }
    InputValidationCommand ValidationCommand { get; set; }
    public static DependencyProperty ValidationCommandProperty { get; }
    InputValidationContext ValidationContext { get; set; }
    IObservableVector&lt;InputValidationError&gt; ValidationErrors { get; }
    event TypedEventHandler&lt;IInputValidationControl, HasValidationErrorsChangedEventArgs&gt; HasValidationErrorsChanged;
    event TypedEventHandler&lt;IInputValidationControl, InputValidationErrorEventArgs&gt; ValidationError;
  }
  public enum BackgroundSizing
  public sealed class Border : FrameworkElement {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
    BrushTransition BackgroundTransition { get; set; }
  }
  public class CalendarDatePicker : Control {
    object Description { get; set; }
    public static DependencyProperty DescriptionProperty { get; }
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
  }
  public class ComboBox : Selector, IInputValidationControl, IInputValidationControl2 {
    object Description { get; set; }
    public static DependencyProperty DescriptionProperty { get; }
    DataTemplate ErrorTemplate { get; set; }
    public static DependencyProperty ErrorTemplateProperty { get; }
    bool HasValidationErrors { get; }
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
    InputValidationKind InputValidationKind { get; set; }
    public static DependencyProperty InputValidationKindProperty { get; }
    InputValidationMode InputValidationMode { get; set; }
    public static DependencyProperty InputValidationModeProperty { get; }
    bool IsEditable { get; set; }
    public static DependencyProperty IsEditableProperty { get; }
    string Text { get; set; }
    Style TextBoxStyle { get; set; }
    public static DependencyProperty TextBoxStyleProperty { get; }
    public static DependencyProperty TextProperty { get; }
    InputValidationCommand ValidationCommand { get; set; }
    public static DependencyProperty ValidationCommandProperty { get; }
    InputValidationContext ValidationContext { get; set; }
    IObservableVector&lt;InputValidationError&gt; ValidationErrors { get; }
    event TypedEventHandler&lt;IInputValidationControl, HasValidationErrorsChangedEventArgs&gt; HasValidationErrorsChanged;
    event TypedEventHandler&lt;ComboBox, ComboBoxTextSubmittedEventArgs&gt; TextSubmitted;
    event TypedEventHandler&lt;IInputValidationControl, InputValidationErrorEventArgs&gt; ValidationError;
  }
  public sealed class ComboBoxTextSubmittedEventArgs
  public class CommandBarFlyout : FlyoutBase
  public class ContentPresenter : FrameworkElement {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
    BrushTransition BackgroundTransition { get; set; }
  }
  public class Control : FrameworkElement {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
    CornerRadius CornerRadius { get; set; }
    public static DependencyProperty CornerRadiusProperty { get; }
  }
  public enum ControlHeaderPlacement
  public class DataTemplateSelector : IElementFactory {
    UIElement GetElement(ElementFactoryGetArgs args);
    void RecycleElement(ElementFactoryRecycleArgs args);
  }
  public class DatePicker : Control {
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
    IReference&lt;DateTime&gt; NullableDate { get; set; }
    public static DependencyProperty NullableDateProperty { get; }
  }
  public class DropDownButton : Button
  public class DropDownButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider
  public class Frame : ContentControl, INavigate {
    bool IsNavigationStackEnabled { get; set; }
    public static DependencyProperty IsNavigationStackEnabledProperty { get; }
    bool NavigateToType(TypeName sourcePageType, object parameter, FrameNavigationOptions navigationOptions);
  }
  public class Grid : Panel {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
  }
  public sealed class HasValidationErrorsChangedEventArgs
  public class IconSourceElement : IconElement
  public interface IInputValidationControl
  public interface IInputValidationControl2
  public sealed class InputPropertyAttribute : Attribute
  public class InputValidationCommand
  public class InputValidationContext
  public sealed class InputValidationError
  public enum InputValidationErrorEventAction
  public sealed class InputValidationErrorEventArgs
  public enum InputValidationKind
  public enum InputValidationMode
  public interface IScrollAnchorProvider
  public class MenuBar : Control
  public class MenuBarItem : Control
  public class MenuBarItemFlyout : MenuFlyout
  public class NavigationView : ContentControl {
    UIElement ContentOverlay { get; set; }
    public static DependencyProperty ContentOverlayProperty { get; }
    bool IsPaneVisible { get; set; }
    public static DependencyProperty IsPaneVisibleProperty { get; }
    NavigationViewOverflowLabelMode OverflowLabelMode { get; set; }
    public static DependencyProperty OverflowLabelModeProperty { get; }
    UIElement PaneCustomContent { get; set; }
    public static DependencyProperty PaneCustomContentProperty { get; }
    NavigationViewPaneDisplayMode PaneDisplayMode { get; set; }
    public static DependencyProperty PaneDisplayModeProperty { get; }
    UIElement PaneHeader { get; set; }
    public static DependencyProperty PaneHeaderProperty { get; }
    NavigationViewSelectionFollowsFocus SelectionFollowsFocus { get; set; }
    public static DependencyProperty SelectionFollowsFocusProperty { get; }
    NavigationViewShoulderNavigationEnabled ShoulderNavigationEnabled { get; set; }
    public static DependencyProperty ShoulderNavigationEnabledProperty { get; }
    NavigationViewTemplateSettings TemplateSettings { get; }
    public static DependencyProperty TemplateSettingsProperty { get; }
  }
  public class NavigationViewItem : NavigationViewItemBase {
    bool SelectsOnInvoked { get; set; }
    public static DependencyProperty SelectsOnInvokedProperty { get; }
  }
  public sealed class NavigationViewItemInvokedEventArgs {
    NavigationViewItemBase InvokedItemContainer { get; }
    NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
  }
  public enum NavigationViewOverflowLabelMode
  public enum NavigationViewPaneDisplayMode
  public sealed class NavigationViewSelectionChangedEventArgs {
    NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
    NavigationViewItemBase SelectedItemContainer { get; }
  }
  public enum NavigationViewSelectionFollowsFocus
  public enum NavigationViewShoulderNavigationEnabled
  public class NavigationViewTemplateSettings : DependencyObject
  public class Panel : FrameworkElement {
    BrushTransition BackgroundTransition { get; set; }
  }
  public sealed class PasswordBox : Control, IInputValidationControl, IInputValidationControl2 {
    bool CanPasteClipboardContent { get; }
    public static DependencyProperty CanPasteClipboardContentProperty { get; }
    object Description { get; set; }
    public static DependencyProperty DescriptionProperty { get; }
    DataTemplate ErrorTemplate { get; set; }
    public static DependencyProperty ErrorTemplateProperty { get; }
    bool HasValidationErrors { get; }
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
    InputValidationKind InputValidationKind { get; set; }
    public static DependencyProperty InputValidationKindProperty { get; }
    InputValidationMode InputValidationMode { get; set; }
    public static DependencyProperty InputValidationModeProperty { get; }
    FlyoutBase SelectionFlyout { get; set; }
    public static DependencyProperty SelectionFlyoutProperty { get; }
    InputValidationCommand ValidationCommand { get; set; }
    public static DependencyProperty ValidationCommandProperty { get; }
    InputValidationContext ValidationContext { get; set; }
    IObservableVector&lt;InputValidationError&gt; ValidationErrors { get; }
    event TypedEventHandler&lt;IInputValidationControl, HasValidationErrorsChangedEventArgs&gt; HasValidationErrorsChanged;
    event TypedEventHandler&lt;IInputValidationControl, InputValidationErrorEventArgs&gt; ValidationError;
    void PasteFromClipboard();
  }
  public class RelativePanel : Panel {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
  }
  public class RichEditBox : Control {
    object Description { get; set; }
    public static DependencyProperty DescriptionProperty { get; }
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
    FlyoutBase ProofingMenuFlyout { get; }
    public static DependencyProperty ProofingMenuFlyoutProperty { get; }
    FlyoutBase SelectionFlyout { get; set; }
    public static DependencyProperty SelectionFlyoutProperty { get; }
    RichEditTextDocument TextDocument { get; }
   event TypedEventHandler&lt;RichEditBox, RichEditBoxSelectionChangingEventArgs&gt; SelectionChanging;
  }
  public sealed class RichEditBoxSelectionChangingEventArgs
  public sealed class RichTextBlock : FrameworkElement {
    FlyoutBase SelectionFlyout { get; set; }
    public static DependencyProperty SelectionFlyoutProperty { get; }
    void CopySelectionToClipboard();
  }
  public sealed class ScrollContentPresenter : ContentPresenter {
    bool CanContentRenderOutsideBounds { get; set; }
    public static DependencyProperty CanContentRenderOutsideBoundsProperty { get; }
    bool SizesContentToTemplatedParent { get; set; }
    public static DependencyProperty SizesContentToTemplatedParentProperty { get; }
  }
  public sealed class ScrollViewer : ContentControl, IScrollAnchorProvider {
    bool CanContentRenderOutsideBounds { get; set; }
    public static DependencyProperty CanContentRenderOutsideBoundsProperty { get; }
    UIElement CurrentAnchor { get; }
    double HorizontalAnchorRatio { get; set; }
    public static DependencyProperty HorizontalAnchorRatioProperty { get; }
    bool ReduceViewportForCoreInputViewOcclusions { get; set; }
    public static DependencyProperty ReduceViewportForCoreInputViewOcclusionsProperty { get; }
    double VerticalAnchorRatio { get; set; }
    public static DependencyProperty VerticalAnchorRatioProperty { get; }
    event TypedEventHandler&lt;ScrollViewer, AnchorRequestedEventArgs&gt; AnchorRequested;
    public static bool GetCanContentRenderOutsideBounds(DependencyObject element);
    void RegisterAnchorCandidate(UIElement element);
    public static void SetCanContentRenderOutsideBounds(DependencyObject element, bool canContentRenderOutsideBounds);
    void UnregisterAnchorCandidate(UIElement element);
  }
  public class Slider : RangeBase {
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
  }
  public class SplitButton : ContentControl
  public class SplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
  public sealed class SplitButtonClickEventArgs
  public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
  }
  public sealed class TextBlock : FrameworkElement {
    FlyoutBase SelectionFlyout { get; set; }
    public static DependencyProperty SelectionFlyoutProperty { get; }
    void CopySelectionToClipboard();
  }
  public class TextBox : Control, IInputValidationControl, IInputValidationControl2 {
    bool CanPasteClipboardContent { get; }
    public static DependencyProperty CanPasteClipboardContentProperty { get; }
    bool CanRedo { get; }
    public static DependencyProperty CanRedoProperty { get; }
    bool CanUndo { get; }
    public static DependencyProperty CanUndoProperty { get; }
    object Description { get; set; }
    public static DependencyProperty DescriptionProperty { get; }
   DataTemplate ErrorTemplate { get; set; }
    public static DependencyProperty ErrorTemplateProperty { get; }
    bool HasValidationErrors { get; }
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
    InputValidationKind InputValidationKind { get; set; }
    public static DependencyProperty InputValidationKindProperty { get; }
    InputValidationMode InputValidationMode { get; set; }
    public static DependencyProperty InputValidationModeProperty { get; }
    FlyoutBase ProofingMenuFlyout { get; }
    public static DependencyProperty ProofingMenuFlyoutProperty { get; }
    FlyoutBase SelectionFlyout { get; set; }
    public static DependencyProperty SelectionFlyoutProperty { get; }
    InputValidationCommand ValidationCommand { get; set; }
    public static DependencyProperty ValidationCommandProperty { get; }
    InputValidationContext ValidationContext { get; set; }
    IObservableVector&lt;InputValidationError&gt; ValidationErrors { get; }
    event TypedEventHandler&lt;IInputValidationControl, HasValidationErrorsChangedEventArgs&gt; HasValidationErrorsChanged;
    event TypedEventHandler&lt;TextBox, TextBoxSelectionChangingEventArgs&gt; SelectionChanging;
    event TypedEventHandler&lt;IInputValidationControl, InputValidationErrorEventArgs&gt; ValidationError;
    void ClearUndoRedoHistory();
    void CopySelectionToClipboard();
    void CutSelectionToClipboard();
    void PasteFromClipboard();
    void Redo();
    void Undo();
  }
  public sealed class TextBoxSelectionChangingEventArgs
  public class TextCommandBarFlyout : CommandBarFlyout
  public class TimePicker : Control {
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
    IReference&lt;TimeSpan&gt; NullableTime { get; set; }
    public static DependencyProperty NullableTimeProperty { get; }
  }
  public class ToggleSplitButton : SplitButton
  public class ToggleSplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IToggleProvider
  public sealed class ToggleSplitButtonIsCheckedChangedEventArgs
  public sealed class ToggleSwitch : Control {
    ControlHeaderPlacement HeaderPlacement { get; set; }
    public static DependencyProperty HeaderPlacementProperty { get; }
  }
  public class ToolTip : ContentControl {
    IReference&lt;Rect&gt; PlacementRect { get; set; }
    public static DependencyProperty PlacementRectProperty { get; }
  }
  public class TreeView : Control {
    bool CanDragItems { get; set; }
    public static DependencyProperty CanDragItemsProperty { get; }
    bool CanReorderItems { get; set; }
    public static DependencyProperty CanReorderItemsProperty { get; }
    Style ItemContainerStyle { get; set; }
    public static DependencyProperty ItemContainerStyleProperty { get; }
    StyleSelector ItemContainerStyleSelector { get; set; }
    public static DependencyProperty ItemContainerStyleSelectorProperty { get; }
    TransitionCollection ItemContainerTransitions { get; set; }
    public static DependencyProperty ItemContainerTransitionsProperty { get; }
    object ItemsSource { get; set; }
    public static DependencyProperty ItemsSourceProperty { get; }
    DataTemplate ItemTemplate { get; set; }
    public static DependencyProperty ItemTemplateProperty { get; }
    DataTemplateSelector ItemTemplateSelector { get; set; }
    public static DependencyProperty ItemTemplateSelectorProperty { get; }
    event TypedEventHandler&lt;TreeView, TreeViewDragItemsCompletedEventArgs&gt; DragItemsCompleted;
    event TypedEventHandler&lt;TreeView, TreeViewDragItemsStartingEventArgs&gt; DragItemsStarting;
    DependencyObject ContainerFromItem(object item);
    DependencyObject ContainerFromNode(TreeViewNode node);
    object ItemFromContainer(DependencyObject container);
    TreeViewNode NodeFromContainer(DependencyObject container);
  }
  public sealed class TreeViewCollapsedEventArgs {
    object Item { get; }
  }
  public sealed class TreeViewDragItemsCompletedEventArgs
  public sealed class TreeViewDragItemsStartingEventArgs
  public sealed class TreeViewExpandingEventArgs {
    object Item { get; }
  }
  public class TreeViewItem : ListViewItem {
    bool HasUnrealizedChildren { get; set; }
    public static DependencyProperty HasUnrealizedChildrenProperty { get; }
    object ItemsSource { get; set; }
    public static DependencyProperty ItemsSourceProperty { get; }
  }
  public class TwoPaneView : Control
  public enum TwoPaneViewMode
  public enum TwoPaneViewPriority
  public enum TwoPaneViewTallModeConfiguration
  public enum TwoPaneViewWideModeConfiguration
  public sealed class WebView : FrameworkElement {
    event TypedEventHandler&lt;WebView, WebViewWebResourceRequestedEventArgs&gt; WebResourceRequested;
  }
  public sealed class WebViewWebResourceRequestedEventArgs
}
namespace Windows.UI.Xaml.Controls.Maps {
  public enum MapTileAnimationState
  public sealed class MapTileBitmapRequestedEventArgs {
    int FrameIndex { get; }
  }
  public class MapTileSource : DependencyObject {
    MapTileAnimationState AnimationState { get; }
    public static DependencyProperty AnimationStateProperty { get; }
    bool AutoPlay { get; set; }
    public static DependencyProperty AutoPlayProperty { get; }
    int FrameCount { get; set; }
    public static DependencyProperty FrameCountProperty { get; }
    TimeSpan FrameDuration { get; set; }
    public static DependencyProperty FrameDurationProperty { get; }
    void Pause();
    void Play();
    void Stop();
  }
  public sealed class MapTileUriRequestedEventArgs {
    int FrameIndex { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class CommandBarFlyoutCommandBar : CommandBar
  public sealed class CommandBarFlyoutCommandBarTemplateSettings : DependencyObject
  public class FlyoutBase : DependencyObject {
    bool AreOpenCloseAnimationsEnabled { get; set; }
    public static DependencyProperty AreOpenCloseAnimationsEnabledProperty { get; }
    bool InputDevicePrefersPrimaryCommands { get; }
    public static DependencyProperty InputDevicePrefersPrimaryCommandsProperty { get; }
    bool IsOpen { get; }
    public static DependencyProperty IsOpenProperty { get; }
    FlyoutShowMode ShowMode { get; set; }
    public static DependencyProperty ShowModeProperty { get; }
    public static DependencyProperty TargetProperty { get; }
    void ShowAt(DependencyObject placementTarget, FlyoutShowOptions showOptions);
  }
  public enum FlyoutPlacementMode {
    Auto = 13,
    BottomEdgeAlignedLeft = 7,
    BottomEdgeAlignedRight = 8,
    LeftEdgeAlignedBottom = 10,
    LeftEdgeAlignedTop = 9,
    RightEdgeAlignedBottom = 12,
    RightEdgeAlignedTop = 11,
    TopEdgeAlignedLeft = 5,
    TopEdgeAlignedRight = 6,
  }
  public enum FlyoutShowMode
  public sealed class FlyoutShowOptions : DependencyObject
  public class NavigationViewItemPresenter : ContentControl
}
namespace Windows.UI.Xaml.Core.Direct {
  public interface IXamlDirectObject
  public sealed class XamlDirect
  public enum XamlEventIndex
  public enum XamlPropertyIndex
  public enum XamlTypeIndex
}
namespace Windows.UI.Xaml.Data {
  public sealed class DataErrorsChangedEventArgs
  public interface INotifyDataErrorInfo
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class DesktopWindowXamlSource : IClosable
  public sealed class DesktopWindowXamlSourceGotFocusEventArgs
  public sealed class DesktopWindowXamlSourceTakeFocusRequestedEventArgs
  public sealed class WindowsXamlManager : IClosable
  public enum XamlSourceFocusNavigationReason
  public sealed class XamlSourceFocusNavigationRequest
  public sealed class XamlSourceFocusNavigationResult
}
namespace Windows.UI.Xaml.Input {
  public sealed class CanExecuteRequestedEventArgs
  public sealed class ExecuteRequestedEventArgs
  public sealed class FocusManager {
    public static event EventHandler&lt;GettingFocusEventArgs&gt; GettingFocus;
    public static event EventHandler&lt;FocusManagerGotFocusEventArgs&gt; GotFocus;
    public static event EventHandler&lt;LosingFocusEventArgs&gt; LosingFocus;
    public static event EventHandler&lt;FocusManagerLostFocusEventArgs&gt; LostFocus;
  }
  public sealed class FocusManagerGotFocusEventArgs
  public sealed class FocusManagerLostFocusEventArgs
  public sealed class GettingFocusEventArgs : RoutedEventArgs {
    Guid CorrelationId { get; }
  }
  public sealed class LosingFocusEventArgs : RoutedEventArgs {
    Guid CorrelationId { get; }
  }
  public class StandardUICommand : XamlUICommand
  public enum StandardUICommandKind
  public class XamlUICommand : DependencyObject, ICommand
}
namespace Windows.UI.Xaml.Markup {
  public sealed class FullXamlMetadataProviderAttribute : Attribute
  public interface IXamlBindScopeDiagnostics
  public interface IXamlType2 : IXamlType
}
namespace Windows.UI.Xaml.Media {
  public class Brush : DependencyObject, IAnimationObject {
    void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
    virtual void PopulatePropertyInfoOverride(string propertyName, AnimationPropertyInfo animationPropertyInfo);
  }
  public class Shadow : DependencyObject
  public sealed class ThemeShadow : Shadow
}
namespace Windows.UI.Xaml.Media.Animation {
  public class BasicConnectedAnimationConfiguration : ConnectedAnimationConfiguration
  public sealed class ConnectedAnimation {
    ConnectedAnimationConfiguration Configuration { get; set; }
  }
  public class ConnectedAnimationConfiguration
  public class DirectConnectedAnimationConfiguration : ConnectedAnimationConfiguration
  public class GravityConnectedAnimationConfiguration : ConnectedAnimationConfiguration
  public enum SlideNavigationTransitionEffect
  public sealed class SlideNavigationTransitionInfo : NavigationTransitionInfo {
    SlideNavigationTransitionEffect Effect { get; set; }
    public static DependencyProperty EffectProperty { get; }
  }
}
namespace Windows.UI.Xaml.Navigation {
  public class FrameNavigationOptions
}
namespace Windows.Web.UI {
  public interface IWebViewControl2
  public sealed class WebViewControlNewWindowRequestedEventArgs {
    IWebViewControl TargetWebViewControl { get; set; }
    Deferral GetDeferral();
  }
  public enum WebViewControlPermissionType {
    ImmersiveView = 6,
  }
}
namespace Windows.Web.UI.Interop {
  public sealed class WebViewControl : IWebViewControl, IWebViewControl2 {
    event TypedEventHandler&lt;WebViewControl, object&gt; GotFocus;
    event TypedEventHandler&lt;WebViewControl, object&gt; LostFocus;
    void AddPreLoadedScript(string script);
  }
  public sealed class WebViewControlProcess {
    string Partition { get; }
    string UserAgent { get; }
  }
  public sealed class WebViewControlProcessOptions {
    string Partition { get; set; }
    string UserAgent { get; set; }
  }
}

Removals:

namespace Windows.Gaming.UI {
  public sealed class GameMonitor
  public enum GameMonitoringPermission
}

Go to Source

Share this
03 Jul 2018

Proposal Manager for financial services helps increase proposal win rates

Author: Diana Pallais, Director of Microsoft 365 Industry Marketing
Go to Source

The commercial and corporate lending environment is increasingly competitive and squeezing interest margins for banks and lenders. Bank lending teams must navigate a stream of documents—such as client financials, collateral assets, and regulatory attestations. They must follow protocols that thoroughly analyze the risk attached to a credit facility and income potential of business loans and capital investments. Since lending proposals contain sensitive client information, strict privacy, security, and compliance measures are required. In addition, financial services institutions are hampered by disjointed systems and manual processes that are costly and slow—often leading to inconsistent results, higher error rates, and increased costs.

To win business in this competitive market, lending teams need the right tools to deliver tailored proposals quickly and easily. Built on the Microsoft 365 platform, the Proposal Manager solution is designed specifically for corporate and commercial banks to:

  • Streamline, automate, and speed up the lending process.
  • Create more effective proposals.
  • Collaborate across the bank with strict confidentiality.

The solution was developed by the Microsoft Financial Services team and developers as part of their focus to build vertical-specific solutions. No other cloud productivity providers offer a true banking-specific, end-to-end proposal management solution—architected from the ground up using the Microsoft 365 productivity suite.

The solution is fully customizable and adaptable by your enterprise development team, so your lending team can:

  • Easily create professional, winning proposals—Save time, sharpen creativity, and present professional commitment letters to increase win rates and improve credit risk management.
  • Streamline proposal management—Simplify the commercial and corporate loan origination process with integrated, automated, and secure tools for document management while orchestrating team workflows and collaboration. Bank managers can facilitate iterative proposal negotiations while ensuring version consistency, empower relationship managers on the go, and help expedite credit committee approvals.
  • Improve collaboration and teamwork—Respond to proposals quickly and collaboratively with connected, company-wide communications and collaboration tools. Meet tight deadlines and keep the proposal process moving seamlessly by sharing and collaborating in real-time. Lead proposal reviews and whiteboarding sessions with enterprise-class email, voice, and video.

The numbers don’t lie. The impact a solution like this could have for your firm is significant. A recent Capgemini study found that back-office commercial bank employees spend about 80 percent of their time on repetitive and manual tasks. The same study also cites that automation will provide more than 25 percent in cost savings by automating data-intensive and repetitive tasks. Can you imagine what all your employees could achieve if their time were freed up to tackle other revenue-generating projects?

The Proposal Manager solution is now available to all Microsoft 365 E5 customers. It’s integrated across existing Microsoft 365 workloads to help you transform your proposal process into an agile, collaborative, secure, and client-centered process without requiring significant IT involvement for deployment.

Sales managers and other business leaders can download the Proposal Manager brochure and engage your IT support and development team to understand more about how the solution can help. IT developers can visit GitHub today to get started.

The post Proposal Manager for financial services helps increase proposal win rates appeared first on Microsoft 365 Blog.

Go to Source

Share this
02 Jul 2018

Windows 10 Tip: Yikes, stop that sound! Mute-a-tab in Microsoft Edge

Author: Athima Chansanchai
Go to Source

Does this sound familiar? You’ve got multiple tabs open in your browser and all of a sudden, music or voices blares from one of them. You scramble to find the audio icon on that tab, open the page and scroll down to stop the video that’s playing.

There’s a faster way to shut down that sound.

A new feature with the Windows 10 April 2018 Update can mute tabs in Microsoft Edge.

Here’s how to do it:

Cursor moves to a tab playing music, clicking on it to mute

To mute a tab in Microsoft Edge, click the audio icon

Simply click the audio icon or right-click the tab to choose Mute from the drop down menu.

If you like this, check out more Windows 10 Tips.

Go to Source

Share this
29 Jun 2018
29 Jun 2018

John Wiley & Sons reinvents its digital culture with the Microsoft Cloud

Author: Guest Author
Go to Source

The Wiley logo.

Today’s post was written by Pete Sattler, senior vice president and CIO at John Wiley & Sons.

Profile picture of Pete Sattler, senior vice president and CIO at John Wiley and Sons.As we watch the physical book, magazine, and newsprint markets decline by double digits every year, Wiley—with our 210-year heritage of print publishing—is reinventing our culture to adapt to the demands of a new era in the industry. Today, people want to access as much as possible on their mobile devices. We face the challenge of publishing and delivering content solutions in innovative ways to help our customers succeed, no matter where they are in their education or careers. We need to adopt the same modern tools that we advise our customers to deploy for training and retaining top talent. We want to become proficient at working together in the cloud so that we can connect researchers, learners, and professionals with the information, platforms, and tools they need to share scholarly insights on global issues and challenges.

We’re excited about the business opportunities that this new era brings. And to take advantage of these opportunities, we are empowering Wiley employees with a workplace transformation of our own. We’re using Microsoft Office 365 to transition to a new environment that supports a digital-first mindset. For instance, I have completely done away with paper and can work productively from anywhere. It’s all part of a larger shift at Wiley to drive digital transformation in everything we do. By thinking and working in this new atmosphere, we can innovate products that are relevant to how customers want to consume information. At Wiley, we have a culture of learning, and the ability to openly collaborate is important to the ethos of our organization. We chose Office 365 intelligent communication capabilities to further promote that mindset.

The online collaborative workplaces that we are creating with Office 365 reflect the new physical office spaces that Wiley is building. From traditional cubicles to convenient open areas that inspire people to work together, we’re bringing our new culture to life through flexible floorplans and a growing adoption of mobility and virtual teamwork.

Our IT department is co-sponsoring the workplace transformation project with Archana Singh, executive vice president and chief human resources officer. Together, we aim to deliver contemporary tools that employees can use to virtually and seamlessly connect with each other and with our partners and customers. We put together an amazing Office 365 adoption team to design a new intranet that facilitates collaboration and document management, which is essential to our content-heavy business. Dubbed “The Wire,” the intranet is where Wiley employees start their day. It’s a portal that offers all the powerful Office 365 capabilities and keeps everyone up to date on company news.

Wiley employees would likely discover on their own the range of benefits available via The Wire. However, thanks to the tireless efforts of our Office 365 adoption team, we’ve made considerable headway toward adopting a new way of working. The team organized a global product launch and road show with more than 85 classroom sessions in multiple countries. It’s rewarding to see a more connected mindset taking hold at Wiley to help us deliver the products and services customer demand.

—Pete Sattler

For more on Wiley’s digital transformation, read the case study.

The post John Wiley & Sons reinvents its digital culture with the Microsoft Cloud appeared first on Microsoft 365 Blog.

Go to Source

Share this
29 Jun 2018

Publishing times for Microsoft Store just got faster!

Author: Microsoft Store Team
Go to Source

Updating your Microsoft Store listing is the best way to let customers know more about your app or game. You might want to update the description to call out key features, or add new screenshots and video trailers to help your customers see what your product does best. At times, you may also want to update your app’s or game’s price, either on an indefinite basis or as a limited-time sale to entice new customers to make a purchase.

We’ve heard your feedback that you’d like to be able to see these types of changes in the Microsoft Store sooner. We’ve been working hard to improve our publishing times, and we’re pleased to announce that starting today, submissions that make these types of changes without updating packages will be published faster than ever before. After these submissions go through the certification process (which is often completed in a few hours but may take up to three business days), these updates will be reflected in Microsoft Store in less than one hour!

It’s important to note that updated app packages that you submit to Microsoft Store aren’t affected by these improved processing times, so it could still take up to three business days before submissions with updated packages are published in Microsoft Store. (If no packages are updated, the changes should be published within the hour after the certification process is complete.) If you ever experience a delay of longer than three business days for a submission to be published, we encourage you to contact support so that we can investigate.

Note that when publishing a product for the first time, we recommend submitting at least three days before you want your app or game to appear in the Store. For more precise release scheduling, you can use the Schedule section of the Pricing and availability page when you create your submission to specify a precise release date and time (in UTC or in each local market’s time zone, with the ability to use different dates for different markets if desired).

We hope you’ll find the publishing time improvement makes it easier for you to adjust your pricing quickly or get updated listing details in front of your customer base more quickly.

Go to Source

Share this
29 Jun 2018

New to Microsoft 365 in June—streamlining teamwork and security

Author: Kirk Koenigsbauer, Corporate Vice President for Microsoft 365
Go to Source

This month, we introduced several new capabilities that improve user experience, streamline the management of common tasks, and enhance identity-driven security measures. We also want to hear your feedback, so that we can make sure these updates are relevant and useful to you.

Streamlining the way you work

Updates to the Office 365 user experience—We announced updates for Word, Excel, PowerPoint, OneNote, and Outlook that are designed to embrace the breadth and depth of Office 365 features, while simplifying the user interface and improving accessibility. These updates include a simplified ribbon to encourage focus and collaboration, modern colors and icons to improve rendering and accessibility, and AI-powered search to quickly surface relevant information. These changes will start to roll out to Microsoft 365 and Office 365 subscribers over the next few months.

Connect Office 365 Groups to SharePoint sites—Office 365 Groups can now connect to existing SharePoint sites, allowing newly created Office 365 groups to integrate with your existing SharePoint infrastructure. Connecting a group to a site provides a single starting point to find content, team news, and communications with modern pages, libraries, and lists—without losing any previous content or permissions.

A screenshot displays a SharePoint page. A dropdown from Settings in the upper right shows the user is about to connect a new Office 365 group.

Reduce distractions with Outlook for Android—We introduced “Do Not Disturb” in Outlook for Android to help you reduce distractions and get more done. Now, subscribers can set timed or scheduled periods when email and calendar notifications will be paused. For those with multiple Outlook accounts, Do Not Disturb settings can be customized for each email address—enabling granular control over how you spend your focus-hours.

An animated screenshot highlights the steps a user needs to take to set their Outlook to "Do not disturb." In this case the user has set it to Do not disturb for one hour.

Manage progress in Microsoft To-Do—This month, we introduced “Steps in Microsoft To-Do—a new feature that allows you to break down tasks into smaller, incremental steps—making large projects more manageable. Now, when a you create a To-Do item, you can add a range of detailed steps that are tracked through to completion. We also introduced the ability to share your To-Do lists, enabling you to work together on tasks and complete projects with colleagues and friends.

An animated screenshot highlights a user sending a 1:1 invitation link to a teammate.

Dictation in OneNote—Office 365 subscribers with Windows 10 can now take advantage of hands-free dictation using nine languages in OneNote. Dictation provides a simple, yet transformational, way to express ideas and capture notes using only your voice. You can also make edits using your keyboard without having to pause the recording. Simply click or tap the Dictate icon and start speaking.

Adobe PDF integration in Office 365—Last September, we expanded our strategic partnership with Adobe to focus on integrations between Adobe Sign and Office 365 products, like Microsoft Teams, SharePoint, and Outlook. This month, the Adobe Document Cloud team announced new capabilities for OneDrive and SharePoint that provide improved fidelity when working with PDF documents. Once integrated by your administrator, PDF services provide rich previews of PDF documents in OneDrive and your SharePoint sites, and allow you to combine several files into a single PDF in your document library.

A screenshot displays documents in SharePoint. A Word, Excel, and PowerPoint have been selected and are ready to combine.

Securing the modern workplace

We introduced several new important capabilities that strengthen your organization’s identity-driven security, and ensure important data is kept safe.

Secure your organization with baseline security policy in Azure Active Directory—We introduced the preview of a baseline security policy in Azure AD that enforces multi-factor authentication for privileged accounts. This new policy will apply to all organizations that have Azure Active Directory and help secure the most important accounts in your tenant. Customers can opt in to the baseline protection policy in preview, and at general availability will be opted in by default with the ability to opt out at any time.

Block legacy authentication using Azure Active Directory conditional access—This month, we introduced the preview of conditional access support for blocking legacy authentication, which enables organizations to stop users from authenticating to legacy apps. Identity attacks such as password spray almost exclusively target these older client apps. This feature improves the overall security of your IT environment by getting users to move to more modern clients that support modern authentication mechanisms.

Enhance data classification across your organization—The new Label Activity Explorer in Office 365 provides a quick overview of how the data in your organization has been labeled—allowing you to investigate risky or abnormal activity. To help you manage labeling across the lifecycle of your organization’s content, we enhanced the Data Governance dashboard with new features like the Data Governance toolbox, added links and tools for common data governance tasks, and provided a single resource for guidance.

A screenshot of the Security & Compliance Center in Office 365. The user is exploring the Label Activity Explorer in the Data governance dashboard.

Other updates

  • Microsoft Teams has reached FedRAMP Moderate Compliance and will start rolling out to U.S. Government Community Cloud (GCC) customers on July 17, 2018.
  • Visio Online is now available in Microsoft Teams. Coworkers can now collaborate on Visio Online diagrams from within their team or channel without toggling between apps.
  • SharePoint Swoop—our new enterprise reality show—features a team of MVP experts with just three days to help a Microsoft 365 customer modernize their intranet.
  • At Computex 2018, we outlined our vision for how partners can build intelligent edge devices and solutions.

The post New to Microsoft 365 in June—streamlining teamwork and security appeared first on Microsoft 365 Blog.

Go to Source

Share this

© 2010-2018 Alt-Tech Inc. All rights reserved.

Click Me