Announcing Windows 10 Insider Preview Build 16232 for PC + Build 15228 for Mobile

Hello Windows Insiders!

Today we are excited to release Windows 10 Insider Preview Build 16232 for PC to Windows Insiders in the Fast ring! We are also releasing Windows 10 Mobile Insider Preview Build 15228 to Insiders in the Fast ring. Earlier this week, we announced new end-to-end security features coming with the Windows 10 Fall Creators Update and this build for PC includes some of those new security features.

A note about app updates

In order to provide Windows customers with the highest quality inbox apps possible, we will pause testing new versions of our inbox apps with Windows Insiders. This means that Insiders will not receive app updates from the Windows Store for our inbox apps that are newer than the apps included in the build. Insiders may notice that some features we were testing in our inbox apps – including recent updates to the Photos app – will temporarily disappear. This is because some of our inbox apps won’t have all the latest new features without getting an update from the Store. It is critical that Insiders are experiencing the same version of Windows that will be released as the default version for all Windows users. Insiders will once again start receiving app updates in the very near future. As always, your feedback will help us tremendously to define the overall Windows experience and insure the quality of the Windows 10 Fall Creators Update is excellent for our customers.

What’s New in Build 16232 For PC

Windows Defender Application Guard (WDAG) Improvements:

Giving you access to all the rich features in Microsoft Edge while using Application Guard: Building on our work in Build 16188, we have added support for Microsoft Edge data persistence while using Application Guard. Once enabled, data such as your favorites, cookies, and saved passwords will be persisted across Application Guard sessions. The persisted data will be not be shared or surfaced on the host, but it will be available for future Microsoft Edge in Application Guard sessions.

How to take advantage of Data Persistence when using Microsoft Edge with Application Guard: You enable Data Persistence for Microsoft Edge in Application Guard using Group Policy. Note that Data Persistence for Application Guard with Microsoft Edge sessions is not enabled by default. To enable data persistence, close all Microsoft Edge windows and update the Windows Components > Windows Defender Application Guard policy to turn on data persistence:

To enable data persistence, close all Microsoft Edge windows and update the Windows Components > Windows Defender Application Guard policy to turn on data persistence.

After the Group Policy settings are set, next launch New Application Guard Window from the Microsoft Edge menu:

Launching a New Application Guard Window from the Microsoft Edge menu.

New Application Guard window.

Then browse to your favorite web site and add it to Favorites in Microsoft Edge as shown here:

Browse to your favorite web site and add it to Favorites in Microsoft Edge.

How to find your Favorites after you close Edge with Application Guard: Since you have enabled Data Persistence using Group Policy for Application Guard, the site you saved to your Favorites will be available for later use, with Microsoft Edge in Application Guard, even after reboots as well as build to build upgrades of Windows.

The site you saved to your Favorites will be available for later use, with Microsoft Edge in Application Guard, even after reboots as well as build to build upgrades of Windows.

Read more about what the Windows Defender Application Guard team has been working on in this latest Insider Preview by visiting this community page

To learn more about what’s coming in Windows Defender Application Guard, please take a look at this new Microsoft Mechanics video.

Introducing Exploit Protection:

We’ve heard your feedback regarding the upcoming EMET EOL, so we’re excited to announce that starting with this build you can now audit, configure, and manage Windows system and application exploit mitigation settings right from the Windows Defender Security Center! You don’t need to be using Windows Defender Antivirus to take advantage of these settings.

After upgrading to this build, you can find these settings by opening the Windows Defender Security Center and going to the App & browser control page:

  • Either right-click the icon in the notification area on the taskbar and click Open, or search via the Start menu for Windows Defender Security Center
  • From Windows Defender Security Center, click on App & browser control and then scroll to the bottom of the resulting screen to find Exploit Protection

Introducing Exploit Protection.

More detailed documentation will follow on Microsoft Docs, and remember that Exploit Protection is a work-in-progress and might not be fully functional just yet!

Introducing Controlled folder access in Windows Defender Antivirus:

In this build, we’re making it easier for you to protect valuable data from malicious apps and threats, such as ransomware. To enable the feature, search for and open the Windows Defender Security Center from Start, go to the Virus & threat protection settings section, and set the switch to On:

Enable Controlled folder access.

Controlled folder access monitors the changes that apps make to files in certain protected folders. If an app attempts to make a change to these files, and the app is blacklisted by the feature, you’ll get a notification about the attempt. You can complement the protected folders with additional locations, and add the apps that you want to allow access to those folders.

Allowing apps can be useful if you’re finding a particular app that you know and trust is being blocked by the Controlled folder access feature. Click Allow an app through Controlled folder access and locate and add the app you want to allow.

Allowing apps can be useful if you’re finding a particular app that you know and trust is being blocked by the Controlled folder access feature.

You can add additional folders to the list of protected folders, but you cannot alter the default list, which includes folders such as Documents, Pictures, Movies, and Desktop. Adding other folders to Controlled folder access can be handy, for example, if you don’t store files in the default Windows libraries or you’ve changed the location of the libraries away from the defaults.

Click Protected folders in the Controlled folder access area and enter the full path of the folder you want to monitor. You can also enter network shares and mapped drives, but environment variables and wildcards are not supported (for right now).

Click Protected folders in the Controlled folder access area and enter the full path of the folder you want to monitor.

Changes, improvements, and fixes for PC

  • We fixed the issue that was causing updating to the latest build to fail and roll back to the previous build if you had the .NET 3.5 Framework installed. You should no longer need to uninstall .NET 3.5 before trying to update to this build.
  • We fixed an issue for those with certain languages installed in the last flight where ctfmon.exe would go into a crash loop, resulting in typing in the Start menu and UWP apps becoming impossible.
  • We’ve listened to feedback and in Windows Defender Security Center you will soon have the option to dismiss recommendations (yellow badged items). In this build, you will see the upcoming addition however it is under construction and not up and running yet.  Stay tuned and we’ll let you know when we have it finished.
  • We fixed an issue where some games like Mass Effect 3 would crash if you used Alt + TAB after 5 minutes of game play.
  • We fixed an issue resulting in Word 2016 crashing if you attempted to ink in it.
  • We fixed an issue where using the new Ctrl + Win + C hotkey to enable and disable color filters would unexpectedly open Settings.
  • We fixed an issue from the last flight where auto-complete in the URL bar of Microsoft Edge might fail on some devices – searching for a partial string instead of the autocompleted text. This fix should also address the feedback some of you were reporting where Cortana sometimes couldn’t keep up with typing on that flight and the letters would end up out of order.
  • We fixed an issue where the File Explorer Ribbon assets were blurry if the window’s DPI was not equal to the system DPI.
  • We fixed an issue resulting in apps that start with X, V or Q being incorrectly categorized in Start on Polish builds.
  • We’ve moved the new Video Playback Settings page to now be listed under the Apps category, and have fixed the issues on the page where the video and battery dropdown weren’t displaying correctly.
  • We fixed an issue with the XAML Acrylic Brush that could result in certain apps, for example Maps, occasionally crashing due to attempting to load acrylic brushes while the app was suspended.
  • We fixed a rare condition that could result in Start menu appearing to flash/flicker continuously.

Known issues for PC

  • Your PC may fail to update to this build with an 0x80070643 and rolls back to the previous build. We are investigating.
  • We’re continuing to investigate reports that the battery status on certain laptops isn’t updating while the device is unplugged. If you think you are seeing this, please send in feedback via Feedback Hub and use the capture feature when logging your feedback so we can get your logs.
  • You may notice some of your inbox apps are now displaying a name that looks like “ms-resource:” and are listed at the bottom of Start. We’re investigating. In the meantime, the app should still launch normally, it’s only the name resource that’s impacted.
  • Some UWP apps such as Twitter will crash on launch.
  • Xbox Live in-game experiences may fail to load. These include gamer profiles, achievement details, and other dialogs that may pop up on top of an Xbox Live-enabled game.
  • Please avoid doing a PC reset via Settings > Update & security > Recovery and choosing “Remove everything”. This may put your device into a reboot loop.
  • Task Manager may hang on launch on this build.

Changes, improvements, and fixes for Mobile

  • We have fixed notifications (SMS, Calendar) with all Fitbit trackers.
  • We have fixed crashes reported while using Photos app.
  • We have fixed a deployment issue in where if an admin uses ActiveSyncCSP to provisioning email account on device running the Windows 10 Creators Update without providing a valid password, and the email server enforces a limited number of denied access retries, then the server will lock out the email account.
  • We have improved battery performance by fixing a bug in a scenario where 30% more power was used during Camera app preview and capture mode.
  • Some Insiders provided feedback that playing video on phone resulted in a black flash and/or stuttering when in landscape mode. We have fixed this issue.
  • We have improved Bluetooth connectivity with Garmin Wearable devices.
  • General improvement in reliability of phones by fixing top crash issues.

Office Insider Poll

Our friends in Office are running a poll on their Twitter account asking what is most important to you as an Office Insider. Help them out by answering the poll! Not an Office Insider? Click here to join the Office Insider Program.

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

Scrutinize the Office 365 roadmap to steer clear of trouble

Microsoft wants Office 365 administrators tracking every new feature and update that it puts out, but that’s not as easy as it sounds.

The cadence of releases for a cloud-hosted product can be a perk, with a steady arrival of innovative tools and functionality. But it can also be a pain, particularly if Microsoft deprecates a component that a business needs.

On its Office 365 roadmap website, Microsoft lists more than 200 features in development, rolling out or recently launched. New or upcoming features range from Advanced Threat Protection Status — which reports on the malware that ATP catches — to an option for users to delay or choose when Office 365 sends their message. As Microsoft expands Office 365 into a security, collaboration, cloud storage, private branch exchange and communication suite, IT admins must stay updated on the latest changes on the platform and alert users on the availability of new apps and features.

These Exchange and Office 365 experts — all TechTarget contributors — offered their insights on how Office 365 administrators can adapt to Microsoft’s constant changes and their experiences with how businesses handle the twists and turns of the Office 365 roadmap.

Perils of constant change

Michel de RooijMichel de Rooij

Many organizations use IT Infrastructure Library-based processes to implement new Office 365 features, which can be problematic because of the service’s rapid rollouts. Instead, look to Microsoft’s Office Insider program, with its fast and slow update rings, to bring updates into your business at the right pace.

Editor’s note: Microsoft’s Office Insider program allows Office 365 subscribers to receive early access to new features that they can test out and provide feedback on.

Let a few power users and IT operate on the fast ring to try out new features, but remember that those updates might never arrive based on your region. For example, I still haven’t received Focused Inbox in Outlook 2016, despite running First Release in Office 365 and Insider Fast for Office 2016. Microsoft sometimes pulls features, which happened to the automatic creation of groups for delegates. Also, Microsoft can turn new features on by default, often without administrative controls. An organization that signs up for these early releases needs to be comfortable with a certain amount of unpredictability.

Finally, Microsoft seems to push for certain features that its customers do not care for, such as the option to create Office 365 Groups when you actually want to create distribution groups.

It’s difficult for email and collaboration tool admins to act proactively against the sudden changes in Office 365’s roadmap, but they should always provide feedback to Microsoft when they have strong opinions about features. Administrator pushback caused Microsoft to pull the change for automatic creation of groups for delegates. There will be discrepancies between what the software provider develops and what customers are comfortable with or actually use.

Keep track of the Office 365 roadmap for changes, both for planned updates and those in development — the latter might arrive sooner than you think.

For more from Michel de Rooij, please visit his contributor page.

Users want the latest and greatest

Reda ChouffaniReda Chouffani

Office 365 changes constantly. Users will hear about new features and demand training for them. Administrators have to adapt, and they might even block new features from end users until IT can thoroughly test these updates. But admins cannot restrict the flow of enhancements as a long-term solution; users will still want to get what’s new. The IT staff needs to consider what users want while it evaluates whether these features provide a tangible benefit to the company.

New features can also be disruptive after organizations adopt and master them, if the service changes. For example, Microsoft offered a free version of its cloud-based business analytics Power BI feature, but some of its capabilities — such as dashboard sharing — disappeared when a new edition superseded the old. Early adopters of Power BI had to choose between a trial or the paid version — or lose the capability altogether.

Office 365 changes constantly. Users will hear about new features and demand training for them.

There are risks, but Office 365’s constant updates can benefit those who plan ahead. Microsoft helps IT departments implement and adopt platform features with its free FastTrack service. FastTrack ensures the IT team uses best practices with Office 365 and also provides technical assistance with implementation of its services.

For more from Reda Chouffani, please visit his contributor page.

Keep an eye on the roadmap

Neil HobsonNeil Hobson

Microsoft’s Office 365 roadmap site lets administrators understand what lies ahead for significant service and feature updates. This roadmap is split into five categories: in development, rolling out, launched, previously released or canceled. To avoid issues, administrators need to check the roadmap regularly for new items that might affect their Office 365 deployment. This gives them the early visibility required to commence high-level planning.

As new features on the roadmap near rollout, Microsoft posts announcements to the Message Center, which can be found within the main Office 365 administration portal. The Message Center also contains dated announcements about changes and actions that prevent or fix issues. Announcements contain a short description of the feature or issue, information on how it will affect the organization, actions to prepare for the update and a link to more detailed information. It is vital that administrators check Message Center posts often to be fully prepared for the imminent changes. Some actions must be completed by a specific date to avoid problems.

Admins can configure Office 365’s tenant release option to manage how the platform pushes out new features. An organization selects the First Release option to receive new features early. Admins can then choose to release those features to the entire organization or just specific users. Alternatively, the Standard Release option means that new features come via the default release schedule.

For more from Neil Hobson, please visit his contributor page.

Powered by WPeMatico

UWP App Diagnostics

At Build this year, we gave a sneak preview of a set of new APIs designed to provide diagnostic information about running apps. You can see the videos here and here – but note that these were based on a pre-release implementation. So, while the Build videos are still correct on broad functionality, the final API names are almost all slightly different. Plus, we added a couple of extra features after Build.

The final versions for the upcoming release are available in the Insider builds from Build 16226, along with the corresponding SDK.

At a high level, these APIs allow an app to:

  • Enumerate a list of running apps, including UWP apps, Win32 apps, system services and so on.
  • For each app, get process-specific metrics on:
    • Memory usage (private commit and working set).
    • CPU usage.
    • Disk reads and writes.
  • For each UWP app, get additional metrics on:
    • Memory usage (including shared commit) equivalent to the Windows.System.MemoryManager report previously available to an app for its own usage.
    • State info: running, suspending, suspended, not running.
    • Energy quota info: under or over.
    • Enumerate a list of any background tasks that are active for the app, including name, trigger type and entry point.
    • Enumerate all the processes for the app (using an enhancement to the existing Windows.System.Diagnostics.ProcessDiagnosticInfo class that was previously restricted to an app for its own usage).

The API has a simple hierarchical structure:

  • The AppDiagnosticInfo type represents a single app. Callers would normally request either a single AppDiagnosticInfo for the app you’re interested in or a list of AppDiagnosticInfos if you’re interested in multiple apps.

  • Once you’ve gotten hold of an AppDiagnosticInfo for an app you’re interested in, you’d call GetResourceGroups to get a list of AppResourceGroupInfo objects. Each AppResourceGroupInfo corresponds to a resource group. An app can define resource groups in its manifest as a way to organize its components (foreground app, background tasks) into groups for resource management purposes. If you don’t define any explicit resource groups, the system will provide at least one (for the foreground app) plus potentially more (if you have out-of-proc background tasks, for example).

  • From there, you’d call any of the AppResourceGroupInfo methods to get snapshot reports of memory usage, execution and energy quota state, and the app’s running background tasks (if any) via the AppResourceGroupMemoryReport, AppResourceGroupStateReport and AppResourceGroupBackgroundTaskReport classes.

  • And finally, each group exposes a list of ProcessDiagnosticInfo objects.

As you can see from the class diagrams, the AppDiagnosticInfo and ProcessDiagnosticInfo each have a link to the other. This means you can get all the rich process-specific info for any running process and get the UWP-specific info for any process related to a UWP app (including Desktop Bridge apps).

These APIs are intended to support app developers who either need more diagnostic support during their own app development and testing, or who want to build a general-purpose diagnostic app and publish it in the Windows Store. Exposing information about other apps raises potential privacy concerns, so if your app uses these APIs, you’ll need to declare the appDiagnostics capability in your manifest, along with the corresponding namespace declaration:


&lt;Package
  xmlns:rescap=&quot;http://schemas.microsoft.com/appx/manifest/foundation/ windows10/restrictedcapabilities&quot;
  IgnorableNamespaces=&quot;uap mp rescap&quot;&gt;
  ...

  &lt;Capabilities&gt;
    &lt;rescap:Capability Name=&quot;appDiagnostics&quot; /&gt;
  &lt;/Capabilities&gt;
&lt;/Package&gt;

This is a restricted capability: If you submit an app with this capability to the Windows Store, this will trigger closer scrutiny. The app must be in the Developer Tools category, and we will examine your app to make sure that it is indeed a developer tool before approving the submission.

At run time, the capability also triggers a user-consent prompt the first time any of the diagnostic APIs are called:

The user is always in control: If permission is denied, then the APIs will only return information about the current app. The prompt is only shown on first use, but the user can change his or her mind any time via the privacy pages in Settings. All apps that use the APIs will be listed here, and the user can toggle permission either globally or on a per-app basis:

Given the richness of the APIs, it’s not too much of a stretch to envisage creating a UWP version of Task Manager. There are a few features that we can’t implement just yet (terminating apps and controlling system services, for example), but certainly most of the data reporting is perfectly possible with the new APIs:

The first thing to do is to request permission to access diagnostics for other apps using AppDiagnosticInfo.RequestAccessAsync. The result could be Denied, Limited (which means you can only get information for the current app package) or Allowed.


DiagnosticAccessStatus diagnosticAccessStatus = 
    await AppDiagnosticInfo.RequestAccessAsync();
switch (diagnosticAccessStatus)
{
    case DiagnosticAccessStatus.Allowed:
        Debug.WriteLine(&quot;We can get diagnostics for all apps.&quot;);
        break;
    case DiagnosticAccessStatus.Limited:
        Debug.WriteLine(&quot;We can only get diagnostics for this app package.&quot;);
        break;
}

Then, to emulate Task Manager, you’d start with a list of the ProcessDiagnosticInfo objects for all running processes.


IReadOnlyList&lt;ProcessDiagnosticInfo&gt; processes = ProcessDiagnosticInfo.GetForProcesses();

For each running process, you can extract the top-level process-specific information such as the ExecutableFileName and the ProcessId. You can also get the more detailed process information from each of the three reports for CpuUsage, MemoryUsage and DiskUsage.


if (processes != null)
{
    foreach (ProcessDiagnosticInfo process in processes)
    {
        string exeName = process.ExecutableFileName;
        string pid = process.ProcessId.ToString();

        ProcessCpuUsageReport cpuReport = process.CpuUsage.GetReport();
        TimeSpan userCpu = cpuReport.UserTime;
        TimeSpan kernelCpu = cpuReport.KernelTime;

        ProcessMemoryUsageReport memReport = process.MemoryUsage.GetReport();
        ulong npp = memReport.NonPagedPoolSizeInBytes;
        ulong pp = memReport.PagedPoolSizeInBytes;
        ulong peakNpp = memReport.PeakNonPagedPoolSizeInBytes;
        //...etc

        ProcessDiskUsageReport diskReport = process.DiskUsage.GetReport();
        long bytesRead = diskReport.BytesReadCount;
        long bytesWritten = diskReport.BytesWrittenCount;
        //...etc
    }
}

For any process associated with a UWP app, the IsPackaged property is true. So, for each of these, you can get from the ProcessDiagnosticInfo to the AppDiagnosticInfo. It might seem strange that we can get AppDiagnosticInfos (plural) from a process – but this is to allow for the possibility that a single process is associated with more than one app. That’s an extremely uncommon scenario, but it is possible in the case of VoIP apps where two or more apps in the same package can share a component running in a separate process at run time. In almost all cases, though, there will only be one AppDiagnosticInfo per process.


if (process.IsPackaged)
{
    IList&lt;AppDiagnosticInfo&gt; diagnosticInfos = process.GetAppDiagnosticInfos();
    if (diagnosticInfos != null &amp;&amp; diagnosticInfos.Count &gt; 0)
    {
        AppDiagnosticInfo diagnosticInfo = diagnosticInfos.FirstOrDefault();
        if (diagnosticInfo != null)
        {
            IList&lt;AppResourceGroupInfo&gt; groups = diagnosticInfo.GetResourceGroups();
            if (groups != null &amp;&amp; groups.Count &gt; 0)
            {

From the AppDiagnosticInfo, you can walk down the hierarchy and get a collection of AppResourceGroupInfos. Then, for each AppResourceGroupInfo, you can get the UWP-specific state and memory information:


AppResourceGroupInfo group = groups.FirstOrDefault();
if (group != null)
{
    string name = diagnosticInfo.AppInfo.DisplayInfo.DisplayName;
    string description = diagnosticInfo.AppInfo.DisplayInfo.Description;
    BitmapImage bitmapImage = await GetLogoAsync(diagnosticInfo);

    AppResourceGroupStateReport stateReport= group.GetStateReport();
    if (stateReport != null)
    {
        string executionStatus = stateReport.ExecutionState.ToString();
        string energyStatus = stateReport.EnergyQuotaState.ToString();
    }

    AppResourceGroupMemoryReport memoryReport = group.GetMemoryReport();
    if (memoryReport != null)
    {
        AppMemoryUsageLevel level = memoryReport.CommitUsageLevel;
        ulong limit = memoryReport.CommitUsageLimit;
        ulong totalCommit = memoryReport.TotalCommitUsage;
        ulong privateCommit = memoryReport.PrivateCommitUsage;
        ulong sharedCommit = totalCommit - privateCommit;
    }
}

Note: to get the packaged logo from the app, there’s a little extra work. You call GetLogo from the AppDisplayInfo to return the data as a stream; if there are multiple logos available, this will return the largest one that is within the specified size.


private async Task&lt;BitmapImage&gt; GetLogoAsync(AppDiagnosticInfo app)
{
    RandomAccessStreamReference stream = 
        app.AppInfo.DisplayInfo.GetLogo(new Size(64, 64));
    IRandomAccessStreamWithContentType content = await stream.OpenReadAsync();
    BitmapImage bitmapImage = new BitmapImage();
    await bitmapImage.SetSourceAsync(content);
    return bitmapImage;
}

Once you’ve collected all the various detailed metrics you’re interested in, it’s a simple matter to populate your viewmodel for data-binding purposes, to perform data analytics or to do whatever other processing you might want.

In a later post, we’ll look at how you can integrate the diagnostic APIs with existing developer tools such as Visual Studio and Appium.

Announcing the Ultimate Game Sale, beginning June 30

Mark your calendars as summer kicks into high gear beginning this Friday with the Ultimate Game Sale, featuring a killer collection of deals on more than 350 games, gaming hardware and accessories. With savings up to 50% across the Microsoft Store, Xbox Store and Windows Store, the Ultimate Game Sale will appeal to PC and Xbox gamers alike.

You could also win one of two Ultimate Prize Packages, worth up to $5,000 each, by participating in the Ultimate Game Face Sweepstakes!

You could also win one of two Ultimate Prize Packages by participating in the Ultimate Game Face Sweepstakes!** Simply share a photo of your Ultimate Game Face on Twitter or Instagram and tag #UltimateGameFace AND #XboxSweepstakes or #PCSweepstakes, now through Monday, July 10, for a chance to win. Visit microsoft.com/ultimategameface for complete details.

We’ll be updating this blog post with specific deals on Friday,, June 30, so bookmark this page and be sure to come back to see all the great Ultimate Game Sale deals.

*All offers shown are available on select items 6/30/2017 to 7/10/2017. Limited quantities available, while supplies last. No rain checks. Availability and pricing varies by location. May not be combinable with other offers. Certain other exclusions and limitations may apply. Not valid on prior orders or purchases; cannot be transferred or otherwise redeemed. Microsoft reserves the right to modify or discontinue any offer at any time. See webpage for each offer’s specific details.

**No Purchase Necessary. Open only to legal residents of the 50 U.S. + DC 14+. Game ends 7/10/17. For details, visit: microsoft.com/ultimategameface/terms.

Accenture to upgrade over 400,000 employees to Windows 10 by 2018

It’s remarkable how much technology can play a role in digitally transforming a business at a global scale. The way we work and collaborate is shifting, and I experience this firsthand every day at Microsoft. I enjoy working closely with customers across all industries who are so committed to their employees and dedicated to empowering them with the latest Microsoft technologies to do more and achieve more anytime, anywhere, like Accenture.

An Enhanced Way of Working

It’s Accenture’s mission to drive digital transformation for their clients, which also means they have to empower their own workforce of over 400,000 employees and become a prime example of what digital transformation can bring. At Accenture, they walk the walk, and talk the talk.

Accenture is preparing the future workforce and enabling their current workforce, which is now 75 percent millennial with a modern desktop. This offers Accenture employees access to the latest productivity apps while keeping their PC always secure and up to date. The way they work is changing and the kind of services they need are “cloud-first” that allow real-time engagement and collaboration. Windows 10, Office 365 and the Microsoft Enterprise Mobility + Security Suite are at the heart of the digital worker at Accenture and helping to increase productivity for them. OneDrive has transformed the way employees work across the company in different time zones, enabling them to collaborate and communicate in real time in a virtualized project environment. In fact, Accenture has the biggest OneDrive in the world at over 6 Peta-bites! Accenture has also seen maturity in Microsoft’s security value proposition with Windows 10 and EMS, allowing employees to operate in both a mobile and secure way.

“Office 365 and Windows 10 are at the heart of a digital worker proposition which is really speeding up our workforce.” – Andrew Wilson, chief operating officer at Accenture
 

Accenture is displaying the art of what’s possible with Microsoft technologies and the company is the largest deployment of Windows 10 – and I’m pleased to share Accenture will be completing over 400,000 Windows 10 upgrades by 2018. Let me share how Accenture is making this all possible.

Windows 10 Deployment

A global Windows 10 project team began the upgrade project in September 2015, which first tested all business applications and validated compatibility with Windows 10. Then, the team proceeded with Windows 10 deployment to employees. By April 2016, initial deployment began with a “two-lane” deployment approach. First, they upgraded all new PCs with Windows 10 and provided a manual upgrade option for early adopters. The second deployment began in August 2016, which addressed existing PCs running Windows 7 and allowed employees to utilize an In-Place Upgrade tool and process that uses OneDrive for file distribution to perform a Windows 10 upgrade.

The In-Place Upgrade Tool played a key part in supporting deployments at pace and scale. The best part is the tool eliminated the need to come into an Accenture office to have an IT person perform the upgrade. Employees could make the upgrade wherever and whenever.

It’s incredible seeing Accenture accomplish the upgrade to Windows 10 in just a span of two years. Check out their case study to learn more.

Windows 10 SDK Preview Build 16225 Released

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 16225 or greater). The Preview SDK Build 16225 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 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 Creators build 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.

Known Issues

  • Designer fails to render: When viewing the XAML in the Designer Window in Visual Studio, the controls fail to render. This can be resolved by using Visual Studio 2017.3 Preview.
  • Compilation fails on non-Windows 10 platforms: When building apps on previous platforms, you may get a build error:

C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll:C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll(0,0): Error WMC0621: Cannot resolve ‘GenXbf.dll’ under path ‘C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll’. Please install the latest version of the Windows 10 Software Development Kit.
Process ‘msbuild.exe’ exited with code ‘1’.

This will occur if the minimum target platform version is set to 10.0.16225.0. To work around this, right click on your project file and choose properties or open your project file in your favorite editor, and change the version to a previous released SDK. For example:


&amp;lt;WindowsTargetPlatformMinVersion&amp;gt;10.0.10586.0&amp;lt;/WindowsTargetPlatformMinVersion&amp;gt;

Breaking Changes

API Updates and Additions

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.

 
namespace Windows.ApplicationModel.Calls {
  public sealed class VoipCallCoordinator {
    VoipPhoneCall SetupNewAcceptedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
  }
  public sealed class VoipPhoneCall {
    void TryShowAppUI();
  }
}
namespace Windows.ApplicationModel {
  public enum StartupTaskState {
    DisabledByPolicy = 3,
  }
}
namespace Windows.Devices.SmartCards {
  public sealed class SmartCardCryptogramGenerator {
    public static bool IsSupported();
  }
  public enum SmartCardCryptogramGeneratorOperationStatus {
    NotSupported = 13,
  }
  public sealed class SmartCardEmulator {
    public static bool IsSupported();
  }
}
namespace Windows.ApplicationModel {
  public static class DesignMode {
    public static bool DesignMode2Enabled { get; }
  }
  public sealed class PackageCatalog {
    IAsyncOperation&amp;lt;PackageCatalogRemoveOptionalPackagesResult&amp;gt; RemoveOptionalPackagesAsync(IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames);
  }
  public sealed class PackageCatalogRemoveOptionalPackagesResult
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    CommandLineLaunch = 1021,
    GameUIProvider = 1019,
    PrintWorkflowForegroundTask = 1018,
    StartupTask = 1020,
  }
  public sealed class CommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class CommandLineActivationOperation
  public interface ICommandLineActivatedEventArgs : IActivatedEventArgs
  public interface IStartupTaskActivatedEventArgs : IActivatedEventArgs
  public sealed class StartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.ApplicationModel.Appointments {
  public sealed class AppointmentStore {
    AppointmentStoreChangeTracker GetChangeTracker(string identity);
  }
  public sealed class AppointmentStoreChangeTracker {
    bool IsTracking { get; }
  }
}
namespace Windows.ApplicationModel.AppService {
  public sealed class AppServiceTriggerDetails {
    IAsyncOperation&amp;lt;bool&amp;gt; CheckCallerForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class GeovisitTrigger : IBackgroundTrigger
  public sealed class PaymentAppCanMakePaymentTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactChangeTracker {
    bool IsTracking { get; }
  }
  public sealed class ContactList {
    ContactListLimitedWriteOperations LimitedWriteOperations { get; }
    ContactChangeTracker GetChangeTracker(string identity);
  }
  public sealed class ContactListLimitedWriteOperations
  public enum ContactListOtherAppWriteAccess {
    Limited = 2,
  }
  public sealed class ContactStore {
    ContactChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Contacts.DataProvider {
  public sealed class ContactDataProviderConnection {
    event TypedEventHandler&amp;lt;ContactDataProviderConnection, ContactListCreateOrUpdateContactRequestEventArgs&amp;gt; CreateOrUpdateContactRequested;
    event TypedEventHandler&amp;lt;ContactDataProviderConnection, ContactListDeleteContactRequestEventArgs&amp;gt; DeleteContactRequested;
  }
  public sealed class ContactListCreateOrUpdateContactRequest
  public sealed class ContactListCreateOrUpdateContactRequestEventArgs
  public sealed class ContactListDeleteContactRequest
  public sealed class ContactListDeleteContactRequestEventArgs
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    string AppUserModelId { get; }
  }
  public enum AppRestartFailureReason
  public static class CoreApplication {
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartAsync(string launchArguments);
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class CoreApplicationView {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataTransferManager {
    public static void ShowShareUI(ShareUIOptions options);
  }
  public sealed class ShareUIOptions
  public enum ShareUITheme
}
namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
  public sealed class ShareOperation {
    IVectorView&amp;lt;Contact&amp;gt; Contacts { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMailbox {
    EmailMailboxChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Payments {
  public sealed class PaymentCanMakePaymentResult
  public enum PaymentCanMakePaymentResultStatus
  public sealed class PaymentMediator {
    IAsyncOperation&amp;lt;PaymentCanMakePaymentResult&amp;gt; CanMakePaymentAsync(PaymentRequest paymentRequest);
  }
  public sealed class PaymentRequest {
    public PaymentRequest(PaymentDetails details, IIterable&amp;lt;PaymentMethodData&amp;gt; methodData, PaymentMerchantInfo merchantInfo, PaymentOptions options, string id);
    string Id { get; }
  }
}
namespace Windows.ApplicationModel.Payments.Provider {
  public sealed class PaymentAppCanMakePaymentTriggerDetails
}
namespace Windows.ApplicationModel.UserActivities {
  public interface IUserActivityContentInfo
  public sealed class UserActivity
  public sealed class UserActivityAttribution
  public sealed class UserActivityChannel
  public sealed class UserActivityContentInfo : IUserActivityContentInfo
  public sealed class UserActivitySession : IClosable
  public enum UserActivityState
  public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
  public static class CoreUserActivityManager
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
  public sealed class BluetoothDeviceId {
    public static BluetoothDeviceId FromId(string deviceId);
  }
  public sealed class BluetoothLEDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattClientNotificationResult {
    ushort BytesSent { get; }
  }
}
namespace Windows.Devices.Geolocation {
  public sealed class Geovisit
  public sealed class GeovisitMonitor
  public sealed class GeovisitStateChangedEventArgs
  public sealed class GeovisitTriggerDetails
  public enum VisitMonitoringScope
  public enum VisitStateChange
}
namespace Windows.Devices.PointOfService {
  public sealed class ClaimedLineDisplay : IClosable {
    LineDisplayCustomGlyphs CustomGlyphs { get; }
    Size MaxBitmapSizeInPixels { get; }
    IVectorView&amp;lt;int&amp;gt; SupportedCharacterSets { get; }
    IVectorView&amp;lt;Size&amp;gt; SupportedScreenSizesInCharacters { get; }
    event TypedEventHandler&amp;lt;ClaimedLineDisplay, LineDisplayStatusUpdatedEventArgs&amp;gt; StatusUpdated;
    IAsyncOperation&amp;lt;string&amp;gt; CheckHealthAsync(UnifiedPosHealthCheckLevel level);
    IAsyncOperation&amp;lt;LineDisplayPowerStatus&amp;gt; CheckPowerStatusAsync();
    LineDisplayAttributes GetAttributes();
    IAsyncOperation&amp;lt;string&amp;gt; GetStatisticsAsync(IIterable&amp;lt;string&amp;gt; statisticsCategories);
    IAsyncOperation&amp;lt;bool&amp;gt; TryClearDescriptorsAsync();
    IAsyncOperation&amp;lt;LineDisplayWindow&amp;gt; TryCreateWindowAsync(Rect viewport, Size windowSize);
    IAsyncOperation&amp;lt;bool&amp;gt; TrySetDescriptorAsync(uint descriptor, LineDisplayDescriptorState descriptorState);
    IAsyncOperation&amp;lt;LineDisplayStoredBitmap&amp;gt; TryStoreStorageFileBitmapAsync(StorageFile bitmap);
    IAsyncOperation&amp;lt;LineDisplayStoredBitmap&amp;gt; TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation&amp;lt;LineDisplayStoredBitmap&amp;gt; TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryUpdateAttributesAsync(LineDisplayAttributes attributes);
  }
  public sealed class LineDisplay : IClosable {
    public static LineDisplayStatisticsCategorySelector StatisticsCategorySelector { get; }
    IAsyncOperation&amp;lt;LineDisplayPowerStatus&amp;gt; CheckPowerStatusAsync();
  }
  public sealed class LineDisplayAttributes
  public sealed class LineDisplayCursor
  public sealed class LineDisplayCursorAttributes
  public enum LineDisplayCursorType
  public sealed class LineDisplayCustomGlyphs
  public enum LineDisplayDescriptorState
  public enum LineDisplayHorizontalAlignment
  public sealed class LineDisplayMarquee
  public enum LineDisplayMarqueeFormat
  public enum LineDisplayPowerStatus
  public sealed class LineDisplayStatisticsCategorySelector
  public sealed class LineDisplayStatusUpdatedEventArgs
  public sealed class LineDisplayStoredBitmap
  public enum LineDisplayVerticalAlignment
  public sealed class LineDisplayWindow : IClosable {
    LineDisplayCursor Cursor { get; }
    LineDisplayMarquee Marquee { get; }
    IAsyncOperation&amp;lt;uint&amp;gt; ReadCharacterAtCursorAsync();
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels, int widthInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStoredBitmapAtCursorAsync(LineDisplayStoredBitmap bitmap);
  }
}
namespace Windows.Devices.Sensors {
  public sealed class Accelerometer {
    public static IAsyncOperation&amp;lt;Accelerometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector(AccelerometerReadingType readingType);
  }
  public sealed class AccelerometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Altimeter {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class AltimeterReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Barometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Barometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class BarometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Compass {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Compass&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class CompassReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Gyrometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Gyrometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class GyrometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Inclinometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Inclinometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
  }
  public sealed class InclinometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class LightSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;LightSensor&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class LightSensorReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Magnetometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Magnetometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class MagnetometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class OrientationSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;OrientationSensor&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
    public static string GetDeviceSelector(SensorReadingType readingType, SensorOptimizationGoal optimizationGoal);
  }
  public sealed class OrientationSensorReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
}
namespace Windows.Devices.Sensors.Custom {
  public sealed class CustomSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class CustomSensorReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
  }
}
namespace Windows.Devices.WiFi {
  public sealed class WiFiAdapter {
    IAsyncOperation&amp;lt;WiFiConnectionResult&amp;gt; ConnectAsync(WiFiAvailableNetwork availableNetwork, WiFiReconnectionKind reconnectionKind, PasswordCredential passwordCredential, string ssid, WiFiConnectionMethod connectionMethod);
    IAsyncOperation&amp;lt;WiFiWpsConfigurationResult&amp;gt; GetWpsConfigurationAsync(WiFiAvailableNetwork availableNetwork);
  }
  public enum WiFiConnectionMethod
  public sealed class WiFiWpsConfigurationResult
  public enum WiFiWpsConfigurationStatus
  public enum WiFiWpsKind
}
namespace Windows.Gaming.Input {
  public sealed class RawGameController : IGameController, IGameControllerBatteryInfo {
    string DisplayName { get; }
    string NonRoamableId { get; }
    IVectorView&amp;lt;SimpleHapticsController&amp;gt; SimpleHapticsControllers { get; }
  }
}
namespace Windows.Gaming.UI {
  public sealed class GameMonitor
  public enum GameMonitoringPermission
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    PresentationLayerDrmMode DrmMode { get; set; }
    PresentationLayerConfig CreateLayerConfig();
    PresentationLayers GetPresentationLayers();
    void SetLayerConfig(PresentationLayerConfig layerConfig);
  }
  public sealed class HolographicCameraRenderingParameters {
    PresentationLayerRenderingParametersQuad GetPresentationLayerRenderingParameters(PresentationLayerQuad layer);
  }
  public sealed class HolographicDisplay {
    double RefreshRate { get; }
  }
  public sealed class HolographicSpace {
    public static bool IsConfigured { get; }
  }
  public sealed class PresentationLayerConfig
  public enum PresentationLayerDrmMode
  public sealed class PresentationLayerQuad
  public sealed class PresentationLayerReference
  public sealed class PresentationLayerRenderingParametersQuad
  public sealed class PresentationLayers
  public sealed class PresentationLayerSettings
  public enum PresentationLayerType
}
namespace Windows.Graphics.Printing.PrintTicket {
  public sealed class PrintTicketCapabilities
  public sealed class PrintTicketFeature
  public enum PrintTicketFeatureSelectionType
  public sealed class PrintTicketOption
  public enum PrintTicketParameterDataType
  public sealed class PrintTicketParameterDefinition
  public sealed class PrintTicketParameterInitializer
  public sealed class PrintTicketValue
  public enum PrintTicketValueType
  public sealed class WorkflowPrintTicket
  public sealed class WorkflowPrintTicketValidationResult
}
namespace Windows.Graphics.Printing.Workflow {
  public sealed class PrintWorkflowBackgroundSession
  public sealed class PrintWorkflowBackgroundSetupRequestedEventArgs
  public sealed class PrintWorkflowConfiguration
  public sealed class PrintWorkflowForegroundSession
  public sealed class PrintWorkflowForegroundSetupRequestedEventArgs
  public sealed class PrintWorkflowObjectModelSourceFileContent
  public sealed class PrintWorkflowObjectModelTargetPackage
  public enum PrintWorkflowSessionStatus
  public sealed class PrintWorkflowSourceContent
  public sealed class PrintWorkflowSpoolStreamContent
  public sealed class PrintWorkflowStreamTarget
  public sealed class PrintWorkflowSubmittedEventArgs
  public sealed class PrintWorkflowSubmittedOperation
  public enum PrintWorkflowSubmittedStatus
  public sealed class PrintWorkflowTarget
  public sealed class PrintWorkflowTriggerDetails
  public sealed class PrintWorkflowUIActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser
  public sealed class PrintWorkflowXpsDataAvailableEventArgs
}
namespace Windows.Management.Deployment {
  public enum AddPackageByAppInstallerOptions : uint
  public sealed class PackageManager {
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; AddPackageAsync(Uri packageUri, IIterable&amp;lt;Uri&amp;gt; dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames, IIterable&amp;lt;Uri&amp;gt; packageUrisToInstall, IIterable&amp;lt;Uri&amp;gt; relatedPackageUris);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; AddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; ProvisionPackageForAllUsersAsync(string packageFamilyName);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; RequestAddPackageAsync(Uri packageUri, IIterable&amp;lt;Uri&amp;gt; dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames, IIterable&amp;lt;Uri&amp;gt; relatedPackageUris);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; RequestAddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; StagePackageAsync(Uri packageUri, IIterable&amp;lt;Uri&amp;gt; dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames, IIterable&amp;lt;Uri&amp;gt; packageUrisToInstall, IIterable&amp;lt;Uri&amp;gt; relatedPackageUris);
  }
}
namespace Windows.Media.Capture {
  public sealed class AppCapture {
    public static IAsyncAction SetAllowedAsync(bool allowed);
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class MediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
  public enum MediaFrameReaderAcquisitionMode
  public sealed class MultiSourceMediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
  public interface IMediaStreamDescriptor2 : IMediaStreamDescriptor
  public sealed class InitializeMediaStreamSourceRequestedEventArgs
  public static class LowLightFusion
  public sealed class LowLightFusionResult : IClosable
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    public static MediaSource CreateFromMediaFrameSource(MediaFrameSource frameSource);
  }
  public sealed class MediaSourceAppServiceConnection
  public sealed class MediaStreamSource : IMediaSource {
    bool IsLive { get; set; }
  }
  public sealed class MseStreamSource : IMediaSource {
    IReference&amp;lt;MseTimeRange&amp;gt; LiveSeekableRange { get; set; }
  }
  public sealed class SceneAnalysisEffectFrame : IClosable, IMediaFrame {
    SceneAnalysisRecommendation AnalysisRecommendation { get; }
  }
  public enum SceneAnalysisRecommendation
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp
}
namespace Windows.Media.MediaProperties {
  public sealed class MediaEncodingProfile {
    IVector&amp;lt;AudioStreamDescriptor&amp;gt; GetAudioTracks();
    IVector&amp;lt;VideoStreamDescriptor&amp;gt; GetVideoTracks();
    void SetAudioTracks(IIterable&amp;lt;AudioStreamDescriptor&amp;gt; value);
    void SetVideoTracks(IIterable&amp;lt;VideoStreamDescriptor&amp;gt; value);
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSessionBufferingStartedEventArgs
  public sealed class MediaPlayer : IClosable {
    event TypedEventHandler&amp;lt;MediaPlayer, object&amp;gt; SubtitleFrameChanged;
    bool RenderSubtitlesToSurface(IDirect3DSurface destination);
    bool RenderSubtitlesToSurface(IDirect3DSurface destination, Rect targetRectangle);
  }
}
namespace Windows.Media.Protection.PlayReady {
  public enum PlayReadyEncryptionAlgorithm {
    Aes128Cbc = 5,
    Unspecified = 65535,
  }
  public enum PlayReadyHardwareDRMFeatures {
    Aes128Cbc = 3,
  }
}
namespace Windows.Media.SpeechRecognition {
  public sealed class SpeechRecognizer : IClosable {
    public static IAsyncOperation&amp;lt;bool&amp;gt; TrySetSystemSpeechLanguageAsync(Language speechLanguage);
  }
}
namespace Windows.Media.SpeechSynthesis {
  public sealed class SpeechSynthesizer : IClosable {
    public static IAsyncOperation&amp;lt;bool&amp;gt; TrySetDefaultVoiceAsync(VoiceInformation voice);
  }
  public sealed class SpeechSynthesizerOptions {
    double AudioPitch { get; set; }
    double AudioVolume { get; set; }
    double SpeakingRate { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    HResult ExtendedError { get; }
  }
  public enum AdaptiveMediaSourceDiagnosticType {
    FatalMediaSourceError = 8,
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public struct BackgroundTransferFileRange
  public sealed class BackgroundTransferRangesDownloadedEventArgs
  public enum BackgroundTransferStatus {
    PausedRecoverableWebErrorStatus = 8,
  }
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    IReference&amp;lt;WebErrorStatus&amp;gt; CurrentWebErrorStatus { get; }
    bool IsRandomAccessRequired { get; set; }
    IVector&amp;lt;WebErrorStatus&amp;gt; RecoverableWebErrorStatuses { get; }
    Uri RequestedUri { get; set; }
    event TypedEventHandler&amp;lt;DownloadOperation, BackgroundTransferRangesDownloadedEventArgs&amp;gt; RangesDownloaded;
    IVector&amp;lt;BackgroundTransferFileRange&amp;gt; GetDownloadedRanges();
    IRandomAccessStreamReference GetResultRandomAccessStreamReference();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class ConnectionProfile {
    IAsyncOperation&amp;lt;IVectorView&amp;lt;ProviderNetworkUsage&amp;gt;&amp;gt; GetProviderNetworkUsageAsync(DateTime startTime, DateTime endTime, NetworkUsageStates states);
  }
  public sealed class ProviderNetworkUsage
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAntennaSar
  public sealed class MobileBroadbandCellCdma
  public sealed class MobileBroadbandCellGsm
  public sealed class MobileBroadbandCellLte
  public sealed class MobileBroadbandCellsInfo
  public sealed class MobileBroadbandCellTdscdma
  public sealed class MobileBroadbandCellUmts
  public sealed class MobileBroadbandModem {
    IAsyncOperation&amp;lt;bool&amp;gt; GetIsPassthroughEnabledAsync();
    IAsyncOperation&amp;lt;MobileBroadbandModemStatus&amp;gt; SetIsPassthroughEnabledAsync(bool value);
  }
  public sealed class MobileBroadbandModemConfiguration {
    MobileBroadbandSarManager SarManager { get; }
  }
  public enum MobileBroadbandModemStatus
  public sealed class MobileBroadbandNetwork {
    IAsyncOperation&amp;lt;MobileBroadbandCellsInfo&amp;gt; GetCellsInfoAsync();
  }
  public sealed class MobileBroadbandSarManager
  public sealed class MobileBroadbandTransmissionStateChangedEventArgs
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
    MessageWebSocketReceiveMode ReceiveMode { get; set; }
  }
  public sealed class MessageWebSocketMessageReceivedEventArgs {
    bool IsMessageComplete { get; }
  }
  public enum MessageWebSocketReceiveMode
  public enum SocketProtectionLevel {
    Unspecified = 9,
  }
  public sealed class StreamSocketControl {
    SocketProtectionLevel MinProtectionLevel { get; set; }
  }
  public sealed class StreamWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public static class WebAccountManager {
    public static IAsyncAction InvalidateAppCacheForAccountAsync(WebAccount webAccount);
    public static IAsyncAction InvalidateAppCacheForAllAccountsAsync();
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRoute {
    bool IsScenic { get; }
  }
  public enum MapRouteOptimization {
    Scenic = 3,
  }
  public sealed class PlaceInfo
  public sealed class PlaceInfoCreateOptions
}
namespace Windows.Storage {
  public sealed class StorageLibrary {
    IAsyncOperation&amp;lt;bool&amp;gt; AreFolderSuggestionsAvailableAsync();
  }
  public sealed class StorageProvider {
    IAsyncOperation&amp;lt;bool&amp;gt; IsPropertySupportedForPartialFileAsync(string propertyCanonicalName);
  }
}
namespace Windows.Storage.Search {
  public enum IndexerOption {
    OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
  }
}
namespace Windows.Storage.Streams {
  public enum FileOpenDisposition
  public sealed class FileRandomAccessStream : IClosable, IInputStream, IOutputStream, IRandomAccessStream {
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenAsync(string filePath, FileAccessMode accessMode);
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenAsync(string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenForUserAsync(User user, string filePath, FileAccessMode accessMode);
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenForUserAsync(User user, string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteAsync(string filePath);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteAsync(string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteForUserAsync(User user, string filePath);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteForUserAsync(User user, string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
  }
}
namespace Windows.System {
  public sealed class AppDiagnosticInfo {
    AppResourceGroupInfoWatcher CreateResourceGroupWatcher();
    public static AppDiagnosticInfoWatcher CreateWatcher();
    IVector&amp;lt;AppResourceGroupInfo&amp;gt; GetResourceGroups();
    public static IAsyncOperation&amp;lt;DiagnosticAccessStatus&amp;gt; RequestAccessAsync();
    public static IAsyncOperation&amp;lt;IVector&amp;lt;AppDiagnosticInfo&amp;gt;&amp;gt; RequestInfoForAppAsync();
    public static IAsyncOperation&amp;lt;IVector&amp;lt;AppDiagnosticInfo&amp;gt;&amp;gt; RequestInfoForAppAsync(string appUserModelId);
    public static IAsyncOperation&amp;lt;IVector&amp;lt;AppDiagnosticInfo&amp;gt;&amp;gt; RequestInfoForPackageAsync(string packageFamilyName);
  }
  public sealed class AppDiagnosticInfoWatcher
  public sealed class AppDiagnosticInfoWatcherEventArgs
  public enum AppDiagnosticInfoWatcherStatus
  public sealed class AppMemoryReport {
    ulong ExpectedTotalCommitLimit { get; }
  }
  public sealed class AppResourceGroupBackgroundTaskReport
  public enum AppResourceGroupEnergyQuotaState
  public enum AppResourceGroupExecutionState
  public sealed class AppResourceGroupInfo
  public sealed class AppResourceGroupInfoWatcher
  public sealed class AppResourceGroupInfoWatcherEventArgs
  public sealed class AppResourceGroupInfoWatcherExecutionStateChangedEventArgs
  public enum AppResourceGroupInfoWatcherStatus
  public sealed class AppResourceGroupMemoryReport
  public sealed class AppResourceGroupStateReport
  public enum DiagnosticAccessStatus
  public sealed class DispatcherQueue
  public sealed class DispatcherQueueController
  public delegate void DispatcherQueueHandler();
  public enum DispatcherQueuePriority
  public sealed class DispatcherQueueShutdownStartingEventArgs
  public sealed class DispatcherQueueTimer
  public static class MemoryManager {
    public static ulong ExpectedAppMemoryUsageLimit { get; }
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticActionResult
  public enum DiagnosticActionState
  public sealed class DiagnosticInvoker
  public sealed class ProcessDiagnosticInfo {
    bool IsPackaged { get; }
    IVector&amp;lt;AppDiagnosticInfo&amp;gt; GetAppDiagnosticInfos();
    public static ProcessDiagnosticInfo TryGetForProcessId(uint processId);
  }
}
namespace Windows.System.Profile {
  public enum SystemIdentificationSource {
    Registry = 3,
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    string ManufacturerDisplayName { get; }
    string ModelDisplayName { get; }
  }
  public static class RemoteSystemKinds {
    public static string Iot { get; }
    public static string Laptop { get; }
    public static string Tablet { get; }
  }
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static bool TrySetHomeGeographicRegion(string region);
    public static bool TrySetLanguages(IIterable&amp;lt;string&amp;gt; languageTags);
  }
}
namespace Windows.UI.Composition {
  public sealed class AmbientLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
    InitialValueExpressionCollection InitialValueExpressions { get; }
  }
  public sealed class CompositionColorGradientStop : CompositionObject
  public sealed class CompositionColorGradientStopCollection : IIterable&amp;lt;CompositionColorGradientStop&amp;gt;, IVector&amp;lt;CompositionColorGradientStop&amp;gt;
  public enum CompositionColorSpace {
    HslLinear = 3,
    RgbLinear = 4,
  }
  public enum CompositionDropShadowSourcePolicy
  public class CompositionGradientBrush : CompositionBrush
  public enum CompositionGradientExtendMode
  public class CompositionLight : CompositionObject {
    VisualUnorderedCollection ExclusionsFromTargets { get; }
  }
  public sealed class CompositionLinearGradientBrush : CompositionGradientBrush
  public class CompositionObject : IClosable {
    DispatcherQueue DispatcherQueue { get; }
  }
  public sealed class CompositionTarget : CompositionObject {
  }
  public sealed class Compositor : IClosable {
    CompositionColorGradientStop CreateColorGradientStop();
    CompositionColorGradientStop CreateColorGradientStop(float offset, Color color);
    CompositionLinearGradientBrush CreateLinearGradientBrush();
    SpringScalarNaturalMotionAnimation CreateSpringScalarAnimation();
    SpringVector2NaturalMotionAnimation CreateSpringVector2Animation();
    SpringVector3NaturalMotionAnimation CreateSpringVector3Animation();
  }
  public sealed class DistantLight : CompositionLight {
    float Intensity { get; set; }
  }
  public sealed class DropShadow : CompositionShadow {
    CompositionDropShadowSourcePolicy SourcePolicy { get; set; }
  }
  public sealed class InitialValueExpressionCollection : CompositionObject, IIterable&amp;lt;IKeyValuePair&amp;lt;string, string&amp;gt;&amp;gt;, IMap&amp;lt;string, string&amp;gt;
  public sealed class LayerVisual : ContainerVisual {
    CompositionShadow Shadow { get; set; }
  }
  public class NaturalMotionAnimation : CompositionAnimation
  public sealed class PointLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class ScalarNaturalMotionAnimation : NaturalMotionAnimation
  public sealed class SpotLight : CompositionLight {
    float InnerConeIntensity { get; set; }
    float OuterConeIntensity { get; set; }
  }
  public sealed class SpringScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class SpringVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class SpringVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public class Vector2NaturalMotionAnimation : NaturalMotionAnimation
  public class Vector3NaturalMotionAnimation : NaturalMotionAnimation
}
namespace Windows.UI.Composition.Effects {
  public sealed class SceneLightingEffect : IGraphicsEffect, IGraphicsEffectSource {
    SceneLightingEffectReflectanceModel ReflectanceModel { get; set; }
  }
  public enum SceneLightingEffectReflectanceModel
}
namespace Windows.UI.Composition.Interactions {
  public sealed class InteractionTracker : CompositionObject {
    void ConfigureVector2PositionInertiaModifiers(IIterable&amp;lt;InteractionTrackerVector2InertiaModifier&amp;gt; modifiers);
  }
  public sealed class InteractionTrackerInertiaNaturalMotion : InteractionTrackerInertiaModifier
  public class InteractionTrackerVector2InertiaModifier : CompositionObject
  public sealed class InteractionTrackerVector2InertiaNaturalMotion : InteractionTrackerVector2InertiaModifier
}
namespace Windows.UI.Core {
  public enum CoreCursorType {
    Person = 15,
    Pin = 14,
  }
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    CoreWindowActivationMode ActivationMode { get; }
    DispatcherQueue DispatcherQueue { get; }
  }
  public enum CoreWindowActivationMode
}
namespace Windows.UI.Input {
  public sealed class RadialControllerConfiguration {
    public static RadialController AppController { get; set; }
    public static bool IsAppControllerEnabled { get; set; }
  }
}
namespace Windows.UI.Input.Inking.Core {
  public sealed class CoreIncrementalInkStroke
  public sealed class CoreInkPresenterHost
}
namespace Windows.UI.Input.Preview.Injection {
  public sealed class InjectedInputGamepadInfo
  public sealed class InputInjector {
    void InitializeGamepadInjection();
    void InjectGamepadInput(InjectedInputGamepadInfo input);
    public static InputInjector TryCreateForAppBroadcastOnly();
    void UninitializeGamepadInjection();
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    IAsyncOperation&amp;lt;IRandomAccessStreamWithContentType&amp;gt; TryGetRenderableModelAsync();
  }
  public sealed class SpatialInteractionSource {
    SpatialInteractionSourceHandedness Handedness { get; }
  }
  public enum SpatialInteractionSourceHandedness
  public sealed class SpatialInteractionSourceLocation {
    IReference&amp;lt;Vector3&amp;gt; AngularVelocity { get; }
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
    SpatialPointerInteractionSourcePose SourcePointerPose { get; }
  }
  public enum SpatialInteractionSourcePositionQuality
  public sealed class SpatialPointerInteractionSourcePose {
    Quaternion Orientation { get; }
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
  }
}
namespace Windows.UI.Shell {
  public static class AdaptiveCardBuilder
  public interface IAdaptiveCard
  public interface IAdaptiveCardBuilderStatics
  public sealed class TaskbarManager
}
namespace Windows.UI.StartScreen {
  public sealed class SecondaryTileVisualElements {
    TileMixedRealityModel MixedRealityModel { get; }
  }
  public sealed class TileMixedRealityModel
}
namespace Windows.UI.Text.Core {
  public enum CoreTextInputScope {
    Digits = 28,
    PinAlphanumeric = 65,
    PinNumeric = 64,
  }
}
namespace Windows.UI.ViewManagement {
  public enum UIElementType {
    AccentColor = 1000,
    NonTextHigh = 1005,
    NonTextLow = 1009,
    NonTextMedium = 1007,
    NonTextMediumHigh = 1006,
    NonTextMediumLow = 1008,
    OverlayOutsidePopup = 1012,
    PageBackground = 1010,
    PopupBackground = 1011,
    TextContrastWithHigh = 1004,
    TextHigh = 1001,
    TextLow = 1003,
    TextMedium = 1002,
  }
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView
  public sealed class CoreInputViewOcclusion
  public enum CoreInputViewOcclusionKind
  public sealed class CoreInputViewOcclusionsChangedEventArgs
}
namespace Windows.UI.WebUI {
  public static class WebUIApplication {
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartAsync(string launchArguments);
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class WebUICommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class WebUIStartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.UI.Xaml {
  public class FrameworkElement : UIElement {
    ElementTheme ActualTheme { get; }
    public static DependencyProperty ActualThemeProperty { get; }
    event TypedEventHandler&amp;lt;FrameworkElement, object&amp;gt; ActualThemeChanged;
  }
  public enum TextAlignment {
    End = 2,
    Start = 1,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent CharacterReceivedEvent { get; }
    IVector&amp;lt;KeyboardAccelerator&amp;gt; KeyboardAccelerators { get; }
    public static RoutedEvent PreviewKeyDownEvent { get; }
    public static RoutedEvent PreviewKeyUpEvent { get; }
    event TypedEventHandler&amp;lt;UIElement, CharacterReceivedRoutedEventArgs&amp;gt; CharacterReceived;
    event KeyEventHandler PreviewKeyDown;
    event KeyEventHandler PreviewKeyUp;
    event TypedEventHandler&amp;lt;UIElement, ProcessKeyboardAcceleratorEventArgs&amp;gt; ProcessKeyboardAccelerators;
    virtual IIterable&amp;lt;DependencyObject&amp;gt; GetChildrenInTabFocusOrder();
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationNotificationKind
  public enum AutomationNotificationProcessing
  public class AutomationPeer : DependencyObject {
    void RaiseNotificationEvent(AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, string displayString, string activityId);
  }
  public class ColorPickerSliderAutomationPeer : SliderAutomationPeer
  public class ColorSpectrumAutomationPeer : FrameworkElementAutomationPeer
  public class AutomationPeer : ListViewItemAutomationPeer
  public class PersonPictureAutomationPeer : FrameworkElementAutomationPeer
  public class RatingControlAutomationPeer : FrameworkElementAutomationPeer
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class BitmapIconSource : IconSource
  public enum CharacterCasing
  public sealed class ColorChangedEventArgs
  public class ColorPicker : Control
  public enum ColorPickerHsvChannel
  public enum ColorSpectrumComponents
  public enum ColorSpectrumShape
  public class ComboBox : Selector {
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
  }
  public class ContentDialog : ContentControl {
    IAsyncOperation&amp;lt;ContentDialogResult&amp;gt; ShowAsync(ContentDialogPlacement placement);
  }
  public enum ContentDialogPlacement
  public class Control : FrameworkElement {
    virtual void OnCharacterReceived(CharacterReceivedRoutedEventArgs e);
    virtual void OnPreviewKeyDown(KeyRoutedEventArgs e);
    virtual void OnPreviewKeyUp(KeyRoutedEventArgs e);
  }
  public enum DisabledFormattingAccelerators : uint
  public class FontIconSource : IconSource
  public class Grid : Panel {
    double ColumnSpacing { get; set; }
    public static DependencyProperty ColumnSpacingProperty { get; }
    double RowSpacing { get; set; }
    public static DependencyProperty RowSpacingProperty { get; }
  }
  public class IconSource : DependencyObject
  public sealed class IsTextTrimmedChangedEventArgs
  public class MediaTransportControls : Control {
    bool IsRepeatButtonVisible { get; set; }
    public static DependencyProperty IsRepeatButtonVisibleProperty { get; }
    bool IsRepeatEnabled { get; set; }
    public static DependencyProperty IsRepeatEnabledProperty { get; }
    bool ShowAndHideAutomatically { get; set; }
    public static DependencyProperty ShowAndHideAutomaticallyProperty { get; }
    void Hide();
    void Show();
  }
  public class NavigationView : ContentControl
  public enum NavigationViewDisplayMode
  public sealed class NavigationViewDisplayModeChangedEventArgs
  public class NavigationViewItem : NavigationViewItemBase
  public class NavigationViewItemBase : ListViewItem
  public class NavigationViewItemHeader : NavigationViewItemBase
  public sealed class NavigationViewItemInvokedEventArgs
  public class NavigationViewItemSeparator : NavigationViewItemBase
  public class NavigationViewList : ListView
  public sealed class NavigationViewSelectionChangedEventArgs
  public enum ParallaxSourceOffsetKind
  public class ParallaxView : FrameworkElement
  public sealed class PasswordBox : Control {
    event TypedEventHandler&amp;lt;PasswordBox, PasswordBoxPasswordChangingEventArgs&amp;gt; PasswordChanging;
  }
  public sealed class PasswordBoxPasswordChangingEventArgs
  public class PathIconSource : IconSource
  public class PersonPicture : Control
  public class RatingControl : Control
  public class RatingItemFontInfo : RatingItemInfo
  public class RatingItemImageInfo : RatingItemInfo
  public class RatingItemInfo : DependencyObject
  public class RichEditBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    DisabledFormattingAccelerators DisabledFormattingAccelerators { get; set; }
    public static DependencyProperty DisabledFormattingAcceleratorsProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    event TypedEventHandler&amp;lt;RichEditBox, TextControlCopyingToClipboardEventArgs&amp;gt; CopyingToClipboard;
    event TypedEventHandler&amp;lt;RichEditBox, TextControlCuttingToClipboardEventArgs&amp;gt; CuttingToClipboard;
  }
  public sealed class RichTextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector&amp;lt;TextHighlighter&amp;gt; TextHighlighters { get; }
    event TypedEventHandler&amp;lt;RichTextBlock, IsTextTrimmedChangedEventArgs&amp;gt; IsTextTrimmedChanged;
  }
  public sealed class RichTextBlockOverflow : FrameworkElement {
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    event TypedEventHandler&amp;lt;RichTextBlockOverflow, IsTextTrimmedChangedEventArgs&amp;gt; IsTextTrimmedChanged;
  }
  public class SplitView : Control {
    event TypedEventHandler&amp;lt;SplitView, object&amp;gt; PaneOpened;
    event TypedEventHandler&amp;lt;SplitView, object&amp;gt; PaneOpening;
  }
  public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
    double Spacing { get; set; }
    public static DependencyProperty SpacingProperty { get; }
  }
  public enum SwipeBehaviorOnInvoked
  public class SwipeControl : ContentControl
  public class SwipeItem : DependencyObject
  public sealed class SwipeItemInvokedEventArgs
  public class SwipeItems : DependencyObject, IIterable&amp;lt;SwipeItem&amp;gt;, IVector&amp;lt;SwipeItem&amp;gt;
  public enum SwipeMode
  public enum Symbol {
    GlobalNavigationButton = 59136,
    Print = 59209,
    Share = 59181,
    XboxOneConsole = 59792,
  }
  public class SymbolIconSource : IconSource
  public sealed class TextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector&amp;lt;TextHighlighter&amp;gt; TextHighlighters { get; }
    event TypedEventHandler&amp;lt;TextBlock, IsTextTrimmedChangedEventArgs&amp;gt; IsTextTrimmedChanged;
  }
  public class TextBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
    event TypedEventHandler&amp;lt;TextBox, TextBoxBeforeTextChangingEventArgs&amp;gt; BeforeTextChanging;
    event TypedEventHandler&amp;lt;TextBox, TextControlCopyingToClipboardEventArgs&amp;gt; CopyingToClipboard;
    event TypedEventHandler&amp;lt;TextBox, TextControlCuttingToClipboardEventArgs&amp;gt; CuttingToClipboard;
  }
  public sealed class TextBoxBeforeTextChangingEventArgs
  public sealed class TextControlCopyingToClipboardEventArgs
  public sealed class TextControlCuttingToClipboardEventArgs
  public class TreeView : Control
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemClickEventArgs
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject, IBindableIterable, IBindableObservableVector, IBindableVector
  public enum TreeViewSelectionMode
  public sealed class XamlBooleanToVisibilityConverter : IValueConverter
  public sealed class XamlIntegerToIndentationConverter : IValueConverter
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    IVector&amp;lt;MapLayer&amp;gt; Layers { get; set; }
    public static DependencyProperty LayersProperty { get; }
    bool TryGetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
    bool TryGetLocationFromOffset(Point offset, out Geopoint location);
  }
  public class MapElement : DependencyObject {
    string MapStyleSheetEntry { get; set; }
    public static DependencyProperty MapStyleSheetEntryProperty { get; }
    string MapStyleSheetEntryState { get; set; }
    public static DependencyProperty MapStyleSheetEntryStateProperty { get; }
    object Tag { get; set; }
    public static DependencyProperty TagProperty { get; }
  }
  public sealed class MapElement3D : MapElement
  public sealed class MapElementsLayer : MapLayer
  public sealed class MapElementsLayerClickEventArgs
  public sealed class MapElementsLayerContextRequestedEventArgs
  public sealed class MapElementsLayerPointerEnteredEventArgs
  public sealed class MapElementsLayerPointerExitedEventArgs
  public class MapLayer : DependencyObject
  public class MapModel3D : DependencyObject
  public enum MapModel3DShadingOption
  public static class MapStyleSheetEntries
  public static class MapStyleSheetEntryStates
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class ColorPickerSlider : Slider
  public class ColorSpectrum : Control
  public class FlyoutBase : DependencyObject {
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
  public sealed class LayoutInformation {
    public static Size GetAvailableSize(UIElement element);
  }
  public class ListViewItemPresenter : ContentPresenter {
    Brush RevealBackground { get; set; }
    public static DependencyProperty RevealBackgroundProperty { get; }
    bool RevealBackgroundShowsAboveContent { get; set; }
    public static DependencyProperty RevealBackgroundShowsAboveContentProperty { get; }
    Brush RevealBorderBrush { get; set; }
    public static DependencyProperty RevealBorderBrushProperty { get; }
    Thickness RevealBorderThickness { get; set; }
    public static DependencyProperty RevealBorderThicknessProperty { get; }
  }
}
namespace Windows.UI.Xaml.Data {
  public enum UpdateSourceTrigger {
    LostFocus = 3,
  }
}
namespace Windows.UI.Xaml.Documents {
  public class Block : TextElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
  }
  public sealed class Hyperlink : Span {
    bool IsTabStop { get; set; }
    public static DependencyProperty IsTabStopProperty { get; }
    int TabIndex { get; set; }
    public static DependencyProperty TabIndexProperty { get; }
  }
  public class TextHighlighter
  public class TextHighlighterBase : DependencyObject
  public struct TextRange
}
namespace Windows.UI.Xaml.Input {
  public sealed class CharacterReceivedRoutedEventArgs : RoutedEventArgs
  public class KeyboardAccelerator : DependencyObject
  public sealed class KeyboardAcceleratorInvokedEventArgs
  public sealed class PointerRoutedEventArgs : RoutedEventArgs {
    bool IsGenerated { get; }
  }
  public sealed class ProcessKeyboardAcceleratorEventArgs
}
namespace Windows.UI.Xaml.Markup {
  public class MarkupExtension
  public sealed class MarkupExtensionReturnTypeAttribute : Attribute
}
namespace Windows.UI.Xaml.Media {
  public enum AcrylicBackgroundSource
  public class AcrylicBrush : XamlCompositionBrushBase
  public class RevealBackgroundBrush : RevealBrush
  public class RevealBorderBrush : RevealBrush
  public class RevealBrush : XamlCompositionBrushBase
  public enum RevealBrushState
}
namespace Windows.Web {
  public enum WebErrorStatus {
    InsufficientRangeSupport = 22,
    MissingContentLengthSupport = 23,
  }
}
 
namespace Windows.Gaming.Preview.GamesEnumeration {
  public static class GameList {
    public static IAsyncOperation&amp;lt;GameListEntry&amp;gt; MergeEntriesAsync(GameListEntry left, GameListEntry right);
    public static IAsyncOperation&amp;lt;IVectorView&amp;lt;GameListEntry&amp;gt;&amp;gt; UnmergeEntryAsync(GameListEntry mergedEntry);
  }
  public sealed class GameListEntry : IGameListEntry {
    GameModeConfiguration GameModeConfiguration { get; }
    GameListEntryLaunchableState LaunchableState { get; }
    IStorageFile LauncherExecutable { get; }
    string LaunchParameters { get; }
    string TitleId { get; }
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile);
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile, string launchParams);
    IAsyncAction SetTitleIdAsync(string id);
  }
  public enum GameListEntryLaunchableState
  public sealed class GameModeConfiguration
  public sealed class GameModeUserConfiguration
}
 
namespace Windows.Graphics.Printing3D {
  public sealed class Printing3D3MFPackage {
    Printing3DPackageCompression Compression { get; set; }
  }
  public enum Printing3DPackageCompression
}
 
namespace Windows.Media.Capture {
  public sealed class AppBroadcastBackgroundService {
    string BroadcastChannel { get; set; }
    string BroadcastLanguage { get; set; }
    string BroadcastTitle { get; set; }
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundService, object&amp;gt; BroadcastChannelChanged;
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundService, object&amp;gt; BroadcastLanguageChanged;
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundService, object&amp;gt; BroadcastTitleChanged;
  }
  public sealed class AppBroadcastBackgroundServiceSignInInfo {
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundServiceSignInInfo, object&amp;gt; UserNameChanged;
  }
  public sealed class AppBroadcastBackgroundServiceStreamInfo {
    void ReportProblemWithStream();
  }
}
 
namespace Windows.Security.EnterpriseData {
  public sealed class FileProtectionInfo {
    bool IsProtectWhileOpenSupported { get; }
  }
}
 
namespace Windows.Services.Maps.Guidance {
  public sealed class GuidanceRoadSegment {
    bool IsScenic { get; }
  }
}
 
namespace Windows.Services.Maps.LocalSearch {
  public static class PlaceInfoHelper
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControlDataHelper : DependencyObject {
    public static MapControl CreateMapControl(bool rasterRenderMode);
  }
}
 
namespace Windows.System.Profile.SystemManufacturers {
  public sealed class OemSupportInfo
  public static class SystemSupportInfo
}
 
namespace Windows.System {
  public static class DateTimeSettings
}
 
namespace Windows.UI.Xaml.Hosting {
  public sealed class DesignerAppManager : IClosable
  public sealed class DesignerAppView : IClosable
  public enum DesignerAppViewState
  public sealed class ProcessExitedEventArgs
}