Category Archives: Cloud Computing

Entrepreneur First cofounder: 'We always have problems with teams who are good friends and love going to the pub'

Alice Bentinck Entrepreneur First

Company builder Entrepreneur First has helped to create highly successful startups like AI startup Magic Pony Technologies and bike light creator Blaze since it was founded in London in 2011 — but things don’t always go to plan.

Each year, Entrepreneur First looks to find high-flying individuals that could start and scale a tech business.

It then pairs them up with another person on its cohort and asks them to come up with an idea for a new tech startup. Typically, a technically skilled founder will be paired with someone who will be able to run a business and crunch the numbers.

However, the founders don’t always gel in the right way once they’re paired.

“We always have problems with teams who are really good friends and they love going to the pub together,” Alice Bentinck, Entrepreneur First cofounder, told Business Insider last month, adding that just because you get on with someone doesn’t mean that you’re going to be good at running a company with them.

When this happens, Entrepreneur First will step in and break teams up.

“We speak with them [the founders] individually about next steps,” said Bentinck. “We try to create an environment where it’s perfectly fine to say: ‘It’s been really great working with you but we’re not being productive and the opportunity cost for us is too high so let’s go and find you someone else. And that’s totally fine.”

About 50% of people on the Entrepreneur First cohort find their cofounder in the first two weeks and the other 50% take up to 10 weeks, Bentinck said.

Blaze CEO Emily BrookeEntrepreneur First provides founders in its cohort with £17,000 in pre-seed funding, mentoring, and workspace. In return, it takes an 8% equity stake in the company that is created. The startup factory raised a £40 million venture capital fund last year to invest in its alumni when they graduate and when they raise subsequent funding rounds. So far, it’s backed approximately 30 companies with this fund.

The shift towards older founders

Bentinck and her cofounder Matt Clifford, the CEO, started out accepting only graduates onto Entrepreneur First, often choosing to take computer science coming out of from Oxbridge. But that’s changed in recent years.

“One of the big shifts over the last year has been really cementing a move away from graduates,” said Bentinck. “So graduates used to make up 100% for [cohorts] 1-3, then it moved down to about 40%. It’s now moving down to 5%.”

She added: “If you’ve just come out of uni — it’s not impossible, it is still true for some people — but it’s relatively rare that you have the depth experience or the depth of skills that mean you can compete with other founders.”

Join the conversation about this story »

NOW WATCH: Science says parents of unsuccessful kids could have these 6 things in common

Microsoft Office 2010
Warning: Invalid argument supplied for foreach() in /home1/mylifeco/public_html/pricecutterstore.com/admin/models/api/amazon.class.php on line 88

Fatal error: Call to a member function xpath() on a non-object in /home1/mylifeco/public_html/pricecutterstore.com/admin/models/api/affiliate_window.class.php on line 129

Technorati Tags: , , , , ,

ChitChat is Silicon Valley’s spammiest new app

spam It began shortly after lunch. The texts appeared, first a trickle. It wasn’t long before the deluge began in earnest. “A friend* added you on ChitChat,” they said. “Tap here … to get it,” they said. WTF is chitchat? — Willis F Jackson III (@wfjackson3) February 4, 2017 What ChitChat is I’m not prepared to say, as I refuse to download it.… Read More
Microsoft Office 2010
Warning: Invalid argument supplied for foreach() in /home1/mylifeco/public_html/pricecutterstore.com/admin/models/api/amazon.class.php on line 88

Fatal error: Call to a member function xpath() on a non-object in /home1/mylifeco/public_html/pricecutterstore.com/admin/models/api/affiliate_window.class.php on line 129

Technorati Tags: , , , , ,

A man who took magic mushrooms for a scientific study said it helped him see a basic truth about relationships

silhouette man clouds alone thinking hopeful

1990 was a year of life and death for Clark Martin. His daughter was born, and he was diagnosed with cancer.

Over the next 20 years, as his daughter took her first steps, experienced her first day of school, and eventually grew into a smart, fiercely independent teenager, doctors waged a blitzkrieg on Martin’s body. Six surgeries. Two experimental treatments. Thousands of doctor visits. The cancer never went into remission, but Martin and his doctors managed to keep it in check by staying vigilant, always catching the disease just as it was on the brink of spreading.

Still, the cancer took its toll. Martin was riddled with the effects of anxiety and depression. He had become so focused on saving his body from the cancer that he hadn’t made time for the people and things in his life that really mattered. His relationships were in shambles; he and his daughter barely spoke.

So in 2010, after reading an article in a magazine about a medical trial that involved giving people with cancer and anxiety the drug psilocybin — the active ingredient in the psychedelic drug magic mushrooms — he contacted the people running the experiment and asked to be enrolled.

After weeks of lengthy questionnaires and interviews, he was selected. On a chilly December morning, Martin walked into the facility at Johns Hopkins, where he was greeted by two researchers, including Bill Richards, a psychologist. The three of them sat and talked in the room for half an hour, going over the details of the study and what might happen. Martin was just one participant in a large, five-year study done at Johns Hopkins and New York University which aimed to look at the effect of psilocybin on cancer patients with anxiety and depression. That study’s promising results have prompted some researchers to liken the treatment to a “surgical intervention.”

The trip

In the homey facility at Johns Hopkins, Martin received a pill, which he swallowed with a glass of water. For study purposes, he couldn’t know whether it was a placebo or psilocybin, the drug the researchers aimed to study.

Patient on couch with chairs 4 psychedelic trial shrooms johns hopkinsNext, he lay back on the couch, covered his eyes with the soft shades he’d been given, and waited.

Within a few minutes, Martin began to feel a sense of intense panic.

“It was quite anxiety-provoking,” he said. “I tried to relax and meditate, but that seemed to make it worse, and I just wanted everything to snap back into place. There was no sense of time, and I realized the drug was in me and there was no stopping it.”

Martin, an avid sailor, told me it reminded him of a frightening experience he’d had when, after a wave knocked him off his boat, he suddenly became disoriented and lost track of the boat, which was floating behind him.

“It was like falling off the boat in the open ocean, looking back, and the boat is gone,” he said. “And then the water disappears. Then you disappear.”

Martin was terrified and felt on the verge of a “full-blown panic attack.” Thanks to the comfort and guidance of his doctors, however, he was eventually able to calm down. Over the next few hours, the terror vanished. It was replaced with a sense of tranquility that Martin still has trouble putting into words.

“With the psilocybin, you get an appreciation — it’s out of time — of well-being, of simply being alive and a witness to life and to everything and to the mystery itself,” said Martin.

‘Relationships are pretty much spontaneous if you’re just present’

couple sailboat sunset sailing sail boatLots of things happened to Martin during his four-hour trip. For a few hours, he remembers feeling at ease; he was simultaneously comfortable, curious, and alert. He recalls a vision of being in a sort of cathedral, where he asked God to speak to him. More than anything else, though, he no longer felt alone.

“The whole ‘you’ thing just kinda drops out into a more timeless, more formless presence,” Martin said.

As his trip slowly began to draw to a close and he began to return to reality, Martin recalls a moment when the two worlds — the one in which he was hallucinating and the reality he could call up from memory — seemed to merge. He turned his attention to his relationships. He thought of his daughter, his friends, his coworkers.

“In my relationships, I had always approached it from a ‘How do I manage this?’ How do I present myself?’ ‘Am I a good listener?’ type of standpoint,” Martin said. “But it dawned on me as I was coming out of [the trip] that relationships are pretty much spontaneous if you’re just present and connecting.”

That shift, which Martin said has deepened since he took the psilocybin in 2010, has had enduring implications for his relationships.

“Now if I’m meeting people, the default is to be just present — not just physically, but mentally present to the conversation,” he said. “That switch has been profound.”

While he felt himself undergo a shift during his trip on psilocybin, Martin says the most enduring changes in his personality and his approach to interacting with those around him unfolded long after he took the drug. For him, the drug was merely a catalyst — a “kick-start,” he likes to call it. By redirecting his perspective for a few hours, the psilocybin unleashed a chain reaction in the way he sees and approaches the world.

The trip “kind of opened up a more intuitive brain processing that I wasn’t fully aware was there,” said Martin.

SEE ALSO: A psychedelics expert says magic mushrooms will be approved for depression by 2027 — here’s why

DON’T MISS: Why psychedelics like magic mushrooms kill the ego and fundamentally transform the brain

Join the conversation about this story »

NOW WATCH: What magic mushrooms do to your brain and state of mind

Technorati Tags: , , , , ,

Trump’s FCC just dropped all investigations into zero-rating practices

shutterstock FCC There’s a new FCC in town and it isn’t wasting any time. Mobile carriers can rest easy today knowing that the Federal Communications Commission is no longer pursuing an investigation into mobile plans that don’t count services like streaming video or music against a user’s data consumption. The practice is more commonly known as zero-rating. Providers putting… Read More

Technorati Tags: , , , , ,

Media startup Odyssey has slashed over 1/3 of its employees, less than a year after raising $25 million

evan burns

Digital media startup Odyssey has laid off 55 people, slashing over a third of its full-time, paid staff less than a year after raising $25 million, CEO Evan Burns confirmed to Business Insider.

This is a dramatic change for a company that board member Michael Lazerow described in April as being the most exciting company to him since he invested in Buzzfeed. (Lazerow sold his startup Buddy Media to Salesforce for $800 million.)

Odyssey has raised $32 million in total, and moved into a new New York office in December.

Burns said that the cuts were across all departments and locations, but focused mostly on the editorial side. The reason he gave for the cuts was a need to completely re-make Odyssey’s technology platform in a way that would allow the startup to grow. “[The tech platform] wasn’t able to scale,” and stalled growth, he said.

Odyssey functions a bit like a college paper on steroids.

The startup has a stable of over 15,000 mostly unpaid writers, typically in the 18-25 age bracket, who produce around one piece a week. The bulk are college students, and Odyssey began as a publication narrowly focused on Greek life. The content Odyssey writers produce spans all sorts of topics, from politics to fashion to sports.

There is no broad editorial mandate, but each Odyssey articles goes through successive layers of editing, first by a “community” editor, who is basically a power user within a geography, and then to the company’s paid staff editors. Those paid editors are where many of the cuts came, Burns said, though some of the product team technical leadership was replaced as well.

The Odyssey idea is to have bright young writers swap their work for being edited and professionally branded, and leverage their networks to have the work spread on social media. This may sound familiar, as the unpaid contributor model initially made Turner-owned sports site Bleacher Report a success, and boosted pageviews for The Huffington Post. (Business Insider has some outside contributors as well.)

Odyssey has been experimenting with different forms of making money, including sponsored content, some of which Odyssey contributors can get paid to write. But right now it’s certainly not a place writers can generally make a significant chunk of cash.

Burns said he is still committed to the underlying business model and structure, but that the tech reboot will take several months to get going at least. 

While some Odyssey writers and editors took to social media to vent about the lack of communication from the company about the layoffs, Burns said the issue was simply in the amount of people they had to reach.

When you have 15,000 writers, and 1,000 various community “editor-in-chiefs” it takes time, Burns said. “It was a couple of days of phone calls” to those who wanted an explanation.

SEE ALSO: Amazon listed its plan to create 100,000 US jobs as the No. 1 highlight this quarter — as it spars with President Trump

Join the conversation about this story »

NOW WATCH: J.K. Rowling roasts fans threatening to burn Harry Potter books because of her anti-Trump rhetoric

Technorati Tags: , , , , ,

Facebook employees are protesting Trump's immigration ban by boycotting flying (FB)

regina dugan

While some of Facebook’s top executives have already spoken out against President Trump’s immigration moratorium, other company employees are protesting the ban by boycotting flying.

A handful of Facebook employees have committed to either fly less or completely boycott flying for the next 90 days in protest of Trump’s order, which bars people from seven predominantly Muslim countries from entering the US for 90 days and bars the admission of all refugees for 120 days.

The protest was organized by Facebook vice president of engineering Regina Dugan, according to a post on her Facebook page Friday. Dugan was poached by Facebook CEO Mark Zuckerberg from Google in early 2016 to lead the social giant’s mysterious Building 8 hardware division.

“Last Sunday, I felt heartbroken,” Dugan wrote Friday in reference to Trump’s executive order. “And I decided that I had to do something. Before I knew it, a small rag tag team of citizen coders had formed. A designer made a logo. We put down words, took shifts, encouraged each other through sleepless nights. Two days later, nofly90.com was live.”

Dugan’s website explains that the boycott is intended to make a statement “that is hard to ignore.”

“Approximately 2 million people fly each day in the United States,” it reads. “If one out of every ten of those people boycott air travel for 90 days, it will make a $5B statement. And that is a roar that is hard to ignore.”

“The boycott of public buses in Montgomery lasted 381 days,” the website continues. “Now it is our turn.”

Some Facebook employees, including several who work within Dugan’s Building 8 division, have shared the website with the hashtag “#nofly90.” Employees from Google and other tech companies have also shared the hashtag.

A Facebook spokesperson told Business Insider that the company wasn’t affiliated with Dugan’s protest and that no company resources were used to create the website.

Mark Zuckerberg was one of first in a long string of tech CEOs to speak out against Trump’s order last week. Facebook COO Sheryl Sandberg later came out and said that the ban defies “the heart and values that define the best of our nation.”

Join the conversation about this story »

NOW WATCH: Kellyanne Conway referred to a terror attack that never occurred as a catalyst for Trump’s immigration ban

Technorati Tags: , , , , ,

How Tesla emerged from the brink of bankruptcy to become America's coolest car company (TSLA)

Elon Musk/Tesla

Tesla Motors officially changed its name on Wednesday. 

The company, known for its impressive electric cars, will now simply go by Tesla Inc. 

While it may seem like a small change, the move marks a symbolic shift for the company. For the last few years, Tesla has been pushing beyond electric cars into new areas of business, specifically energy storage and generation. 

But Tesla’s journey to becoming this new company has not always been easy. While the company has celebrated plenty of achievements, it has also experienced its fair share of setbacks. 

Here’s a breakdown of the company’s most defining moments since its founding. 

SEE ALSO: 21 incredible facts about Elon Musk’s Gigafactory

July 2003: Tesla Motors was founded by a group of Silicon Valley engineers.

While Tesla CEO Elon Musk has led Tesla for the majority of its existence, he wasn’t always at the helm of the company. 

Tesla, which is named after the famous physicist Nikola Tesla, was incorporated in 2003 by two engineers, Martin Eberhard and Marc Tarpenning. Other co-founders included JB Straubel, Ian Wright, and Elon Musk.

Musk led the company’s Series A funding round in 2004, but at the time he served as the company’s chairman. 

Eberhard served as CEO until August 2007, at which time he was reportedly asked to leave the company. 

On November 28, 2007 Ze’ev Drori, an Israeli engineer and businessman, was named CEO of the company. 

 

August 2, 2006: Elon Musk reveals Tesla’s Master Plan.

Musk has never been shy about his intentions for Tesla. 

In 2006, Musk published a blog post entitled “The Secret Tesla Motors Master Plan (just between you and me)” in which he made it crystal clear that Tesla’s mission is to speed up the adoption of a “solar electric economy.”

“As you know, the initial product of Tesla Motors is a high-performance electric sports car called the Tesla Roadster,” Musk said. 

“However, some readers may not be aware of the fact that our long term plan is to build a wide range of models, including affordably priced family cars. This is because the overarching purpose of Tesla Motors (and the reason I am funding the company) is to help expedite the move from a mine-and-burn hydrocarbon economy towards a solar electric economy, which I believe to be the primary, but not exclusive, sustainable solution.” 

November 28, 2007: Ze’ev Drori named CEO.

Tesla announced Drori would take the helm at Tesla at the end of November. Drori officially took the reigns of the company on December 3, 2007. 

Drori, an Israeli engineer and tech veteran, was tasked with bringing Tesla’s first car, the Roadster to market by the first quarter of 2008. 

 

See the rest of the story at Business Insider

Technorati Tags: , , , , ,

Microsoft helps Windows 10 support large Git repos

Microsoft is augmenting Windows 10 and the Visual Studio IDE with a file system to assist developers working with large Git repos.

The company’s Git Virtual File System (GVFS), appearing in GitHub, allows the Git client to scale to repos of any size. It virtualizes the file system beneath a repo to make it appear as though all files in a repo are present, but it downloads a file only the first time it’s opened.

In explaining Microsoft’s motivation, Saeed Noursalehi, Microsoft program manager for Visual Studio Cloud Services, said the company had been bumping up against the client’s limits. “For example, the Windows codebase has over 3.5 million files and is over 270GB in size. The Git client was never designed to work with repos with that many files or that much content.” GVFS manages how much of the repo Git has to consider in operations like checkout and status; any file not already hydrated can be ignored.

To read this article in full or to leave a comment, please click here

Technorati Tags: , , , , ,

ICYMI – Six Updates and a New SDK

Dev Center Acquisition & Engagement Platform

Successful developers use various channels to spread the word about their apps, such as Facebook, Twitter, popular blogs or Windows Dev Center’s own “Promote your app” feature. We’ve grown this solution over the past two and a half years, evolving it into a complete platform with machine-learning algorithms to maximize user acquisition and engagement campaign ROI.

Adding UWP Features to Existing PC Apps

In addition to Windows Store distribution and modern deployment technology, the Desktop Bridge enables you to use exciting Universal Windows Platform (UWP) features and capabilities that were previously unavailable to existing PC software.

Creator’s Update is next week!

Join our livestreamed event on February 8, 2017 to see what’s new for developers in the Windows 10 Creators Update, what it means for your apps and games, and more about Microsoft’s latest developer products. Whether you’re building for the web or UWP, the latest consumer app or line-of-business tool, there’s something in it for you.

Advertise Across Premium Platforms

The first and most important reason to use premium platforms is wider reach. Microsoft premium platforms such as MSN, Outlook, Skype and Solitaire collection are used by millions of users daily, and now your ad campaigns have a chance to showcase your awesome app when they interact on these platforms.

A triple-win with Playtem

Playtem’s monetization strategy is really interesting. The platform, currently available for Unity games deployed to UWP, iOS and Android, combines both ads and in-app purchases.

The latest Desktop Converter update is now in the Windows Store

Desktop App Converter is a tool that enables you to bring your existing desktop apps written for .NET 4.6.1 or Win32 to the Universal Windows Platform (UWP). You can run your desktop installers through the converter in an unattended (silent) mode and obtain an AppX package that you can sideload on your machine or upload to the Windows Store.

Windows 10 SDK Preview Build 15021!

Check it out here: http://wndw.ms/KEXB94

The Windows team would love to hear your feedback. Please keep the feedback coming using our Windows Developer UserVoice site. If you have a direct bug, please use the Windows Feedback tool built directly into Windows 10.

Technorati Tags: , , , , ,

Windows 10 SDK Preview Build 15021 Released

Today, we released a new Windows 10 Creators Update SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 15021 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 15021 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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:

What’s New

Known Issues Windows SDK

  • There are no known issues with the SDK and emulator

API Updates and Additions

The following API changes are under development and new, or updated for this release of the SDK.


namespace Windows.ApplicationModel.Preview.Notes {
  public sealed class NotesWindowManagerPreview {
    void SetFocusToPreviousView();
    IAsyncAction SetThumbnailImageForTaskSwitcherAsync(SoftwareBitmap bitmap);
    void ShowNoteRelativeTo(int noteViewId, int anchorNoteViewId, NotesWindowManagerPreviewShowNoteOptions options);
    void ShowNoteWithPlacement(int noteViewId, IBuffer data, NotesWindowManagerPreviewShowNoteOptions options);
  }
  public sealed class NotesWindowManagerPreviewShowNoteOptions
}
namespace Windows.Devices.Gpio {
  public struct GpioChangeCount
  public sealed class GpioChangeCounter : IClosable
  public enum GpioChangePolarity
  public sealed class GpioChangeReader : IClosable
  public struct GpioChangeRecord
  public enum GpioOpenStatus {
    MuxingConflict = 3,
    UnknownError = 4,
  }
}
namespace Windows.Devices.I2c {
  public enum I2cTransferStatus {
    ClockStretchTimeout = 3,
    UnknownError = 4,
  }
}
namespace Windows.Devices.Pwm {
  public sealed class PwmController {
    public static IAsyncOperation<PwmController> FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
    public static string GetDeviceSelector(string friendlyName);
  }
}

namespace Windows.Devices.SmartCards {
  public sealed class SmartCardTriggerDetails {
    SmartCard SmartCard { get; }
  }
}

namespace Windows.Devices.SmartCards {
  public enum SmartCardCryptogramAlgorithm {
    Sha256Hmac = 8,
  }
  public sealed class SmartCardCryptogramGenerator {
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult> GetAllCryptogramMaterialCharacteristicsAsync(SmartCardUnlockPromptingBehavior promptingBehavior, string materialPackageName);
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync();
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync(string storageKeyName);
    IAsyncOperation<SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult> GetAllCryptogramStorageKeyCharacteristicsAsync();
    IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> ValidateRequestApduAsync(SmartCardUnlockPromptingBehavior promptingBehavior, IBuffer apduToValidate, IIterable<SmartCardCryptogramPlacementStep> cryptogramPlacementSteps);
  }
  public enum SmartCardCryptogramGeneratorOperationStatus {
    ValidationFailed = 12,
  }
  public sealed class SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult
  public sealed class SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult
  public sealed class SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult
  public sealed class SmartCardCryptogramMaterialCharacteristics
  public sealed class SmartCardCryptogramMaterialPackageCharacteristics
  public enum SmartCardCryptogramMaterialProtectionMethod
  public sealed class SmartCardCryptogramStorageKeyCharacteristics
}

namespace Windows.Foundation.Metadata {
  public sealed class FeatureAttribute : Attribute
  public enum FeatureStage
}

namespace Windows.ApplicationModel {
  public sealed class Package {
    IAsyncOperation<PackageContentGroup> GetContentGroupAsync(string name);
    IAsyncOperation<IVector<PackageContentGroup>> GetContentGroupsAsync();
    IAsyncOperation<bool> SetInUseAsync(bool inUse);
    IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names);
    IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names, bool moveToHeadOfQueue);
  }
  public sealed class PackageCatalog {
    event TypedEventHandler<PackageCatalog, PackageContentGroupStagingEventArgs> PackageContentGroupStaging;
    IAsyncOperation<PackageCatalogAddOptionalPackageResult> AddOptionalPackageAsync(string optionalPackageFamilyName);
  }
  public sealed class PackageCatalogAddOptionalPackageResult
  public sealed class PackageContentGroup
  public sealed class PackageContentGroupStagingEventArgs
  public enum PackageContentGroupState
  public sealed class PackageStatus {
    bool IsPartiallyStaged { get; }
  }
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    ContactPanel = 1017,
    LockScreenComponent = 1016,
    PrintWorkflowForegroundTask = 1018,
  }
  public sealed class ContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
  public interface IContactPanelActivatedEventArgs
  public sealed class LockScreenComponentActivatedEventArgs : IActivatedEventArgs
  public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IToastNotificationActivatedEventArgs {
    int CurrentlyShownApplicationViewId { get; }
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class BackgroundTaskBuilder {
    BackgroundTaskRegistrationGroup TaskGroup { get; set; }
  }
  public sealed class BackgroundTaskRegistration : IBackgroundTaskRegistration, IBackgroundTaskRegistration2, IBackgroundTaskRegistration3 {
    public static IMapView<string, BackgroundTaskRegistrationGroup> AllTaskGroups { get; }
    BackgroundTaskRegistrationGroup TaskGroup { get; }
    public static BackgroundTaskRegistrationGroup GetTaskGroup(string groupId);
  }
  public sealed class BackgroundTaskRegistrationGroup
  public sealed class GattCharacteristicNotificationTrigger : IBackgroundTrigger {
    public GattCharacteristicNotificationTrigger(GattCharacteristic characteristic, BluetoothEventTriggeringMode eventTriggeringMode);
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
  }
  public sealed class GattServiceProviderTrigger : IBackgroundTrigger
  public sealed class GattServiceProviderTriggerResult
  public interface IBackgroundTaskRegistration3 : IBackgroundTaskRegistration
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactAnnotation {
    string ContactListId { get; set; }
  }
  public enum ContactAnnotationOperations : uint {
    Share = (uint)32,
  }
  public sealed class ContactAnnotationStore {
    IAsyncOperation<IVectorView<ContactAnnotation>> FindAnnotationsForContactListAsync(string contactListId);
  }
  public sealed class ContactGroup
  public static class ContactManager {
    public static bool IncludeMiddleNameInSystemDisplayAndSort { get; set; }
    public static IAsyncOperation<bool> IsShowFullContactCardSupportedAsync();
  }
  public sealed class ContactManagerForUser {
    void ShowFullContactCard(Contact contact, FullContactCardOptions fullContactCardOptions);
  }
  public sealed class ContactPanel
  public sealed class ContactPanelClosingEventArgs
  public sealed class ContactPanelLaunchFullAppRequestedEventArgs
  public sealed class ContactPicker {
    User User { get; }
    public static ContactPicker CreateForUser(User user);
    public static IAsyncOperation<bool> IsSupportedAsync();
  }
  public sealed class PinnedContactIdsQueryResult
  public sealed class PinnedContactManager
  public enum PinnedContactSurface
}
namespace Windows.ApplicationModel.Core {
  public sealed class CoreApplicationView {
    IPropertySet Properties { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackage {
    event TypedEventHandler<DataPackage, ShareCompletedEventArgs> ShareCompleted;
  }
  public sealed class DataTransferManager {
    event TypedEventHandler<DataTransferManager, ShareProvidersRequestedEventArgs> ShareProvidersRequested;
 }
  public sealed class ShareCompletedEventArgs
  public sealed class ShareProvider
  public delegate void ShareProviderHandler(ShareProviderOperation operation);
  public sealed class ShareProviderOperation
  public sealed class ShareProvidersRequestedEventArgs
  public sealed class ShareTargetInfo
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMessage {
    IVector<EmailRecipient> ReplyTo { get; }
    EmailRecipient SentRepresenting { get; set; }
  }
}
namespace Windows.ApplicationModel.Payments {
  public sealed class PaymentAddress
  public sealed class PaymentCurrencyAmount
  public sealed class PaymentDetails
  public sealed class PaymentDetailsModifier
  public sealed class PaymentItem
  public sealed class PaymentMediator
  public sealed class PaymentMerchantInfo
  public sealed class PaymentMethodData
  public enum PaymentOptionPresence
  public sealed class PaymentOptions
  public sealed class PaymentRequest
  public sealed class PaymentRequestChangedArgs
  public delegate void PaymentRequestChangedHandler(PaymentRequest paymentRequest, PaymentRequestChangedArgs args);
  public sealed class PaymentRequestChangedResult
  public enum PaymentRequestChangeKind
  public enum PaymentRequestCompletionStatus
  public enum PaymentRequestStatus
  public sealed class PaymentRequestSubmitResult
  public sealed class PaymentResponse
  public sealed class PaymentShippingOption
  public enum PaymentShippingType
  public sealed class PaymentToken
}
namespace Windows.ApplicationModel.Payments.Provider {
  public sealed class PaymentAppManager
  public sealed class PaymentTransaction
  public sealed class PaymentTransactionAcceptResult
}
namespace Windows.ApplicationModel.Preview.Holographic {
  public static class HolographicApplicationPreview
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
  public static class LicenseManager {
    public static IAsyncAction RefreshLicensesAsync(LicenseRefreshOption refreshOption);
  }
  public enum LicenseRefreshOption
}
namespace Windows.ApplicationModel.Store.Preview {
  public static class StoreConfiguration {
    public static string GetEnterpriseStoreWebAccountId();
    public static string GetEnterpriseStoreWebAccountIdForUser(User user);
    public static string GetStoreWebAccountId();
    public static string GetStoreWebAccountIdForUser(User user);
    public static void SetEnterpriseStoreWebAccountId(string webAccountId);
    public static void SetEnterpriseStoreWebAccountIdForUser(User user, string webAccountId);
    public static bool ShouldRestrictToEnterpriseStoreOnly();
    public static bool ShouldRestrictToEnterpriseStoreOnlyForUser(User user);
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallItem {
    IVectorView<AppInstallItem> Children { get; }
    bool ItemOperationsMightAffectOtherItems { get; }
  }
  public sealed class AppInstallManager {
    IVectorView<AppInstallItem> AppInstallItemsWithGroupSupport { get; }
    IAsyncOperation<GetEntitlementResult> GetFreeDeviceEntitlementAsync(string storeId, string campaignId, string correlationVector);
    IAsyncOperation<GetEntitlementResult> GetFreeUserEntitlementAsync(string storeId, string campaignId, string correlationVector);
    IAsyncOperation<GetEntitlementResult> GetFreeUserEntitlementForUserAsync(User user, string storeId, string campaignId, string correlationVector);
  }
  public sealed class GetEntitlementResult
  public enum GetEntitlementStatus
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity
  public sealed class UserActivityChannel
  public sealed class UserActivitySession : IClosable
  public enum UserActivityState
  public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
  public static class CoreUserActivityManager
}
namespace Windows.ApplicationModel.UserDataAccounts {
  public sealed class UserDataAccount {
    bool CanShowCreateContactGroup { get; set; }
    IRandomAccessStreamReference Icon { get; set; }
    bool IsProtectedUnderLock { get; set; }
    IPropertySet ProviderProperties { get; }
    IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
    IAsyncOperation<IVectorView<UserDataTaskList>> FindUserDataTaskListsAsync();
    IAsyncOperation<string> TryShowCreateContactGroupAsync();
  }
  public sealed class UserDataAccountStore {
    IAsyncOperation<UserDataAccount> CreateAccountAsync(string userDisplayName, string packageRelativeAppId, string enterpriseId);
  }
}
namespace Windows.ApplicationModel.UserDataTasks {
  public sealed class UserDataTask
  public sealed class UserDataTaskBatch
  public enum UserDataTaskDaysOfWeek : uint
  public enum UserDataTaskDetailsKind
  public enum UserDataTaskKind
  public sealed class UserDataTaskList
  public sealed class UserDataTaskListLimitedWriteOperations
  public enum UserDataTaskListOtherAppReadAccess
  public enum UserDataTaskListOtherAppWriteAccess
  public sealed class UserDataTaskListSyncManager
  public enum UserDataTaskListSyncStatus
  public sealed class UserDataTaskManager
  public enum UserDataTaskPriority
  public enum UserDataTaskQueryKind
  public sealed class UserDataTaskQueryOptions
  public enum UserDataTaskQuerySortProperty
  public sealed class UserDataTaskReader
  public sealed class UserDataTaskRecurrenceProperties
  public enum UserDataTaskRecurrenceUnit
  public sealed class UserDataTaskRegenerationProperties
  public enum UserDataTaskRegenerationUnit
  public enum UserDataTaskSensitivity
  public sealed class UserDataTaskStore
  public enum UserDataTaskStoreAccessType
  public enum UserDataTaskWeekOfMonth
}
namespace Windows.ApplicationModel.UserDataTasks.DataProvider {
  public sealed class UserDataTaskDataProviderConnection
  public sealed class UserDataTaskDataProviderTriggerDetails
  public sealed class UserDataTaskListCompleteTaskRequest
  public sealed class UserDataTaskListCompleteTaskRequestEventArgs
  public sealed class UserDataTaskListCreateOrUpdateTaskRequest
  public sealed class UserDataTaskListCreateOrUpdateTaskRequestEventArgs
  public sealed class UserDataTaskListDeleteTaskRequest
  public sealed class UserDataTaskListDeleteTaskRequestEventArgs
  public sealed class UserDataTaskListSkipOccurrenceRequest
  public sealed class UserDataTaskListSkipOccurrenceRequestEventArgs
  public sealed class UserDataTaskListSyncManagerSyncRequest
  public sealed class UserDataTaskListSyncManagerSyncRequestEventArgs
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter
  public enum BluetoothAddressType {
    Unspecified = 2,
  }
  public sealed class BluetoothDeviceId
  public enum BluetoothError {
    TransportNotSupported = 9,
  }
  public sealed class BluetoothLEDevice : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync();
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(Guid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(Guid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
  }
  public static class BluetoothUuidHelper
}
namespace Windows.Devices.Bluetooth.Background {
  public enum BluetoothEventTriggeringMode
  public sealed class GattCharacteristicNotificationTriggerDetails {
    BluetoothError Error { get; }
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
    IVectorView<GattValueChangedEventArgs> ValueChangedEvents { get; }
  }
  public sealed class GattServiceProviderConnection
  public sealed class GattServiceProviderTriggerDetails
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattCharacteristic {
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync();
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(Guid descriptorUuid);
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(Guid descriptorUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattWriteResult> WriteClientCharacteristicConfigurationDescriptorWithResultAsync(GattClientCharacteristicConfigurationDescriptorValue clientCharacteristicConfigurationDescriptorValue);
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value, GattWriteOption writeOption);
  }
  public sealed class GattCharacteristicsResult
  public sealed class GattClientNotificationResult
  public enum GattCommunicationStatus {
    AccessDenied = 3,
    ProtocolError = 2,
  }
  public sealed class GattDescriptor {
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
  }
  public sealed class GattDescriptorsResult
  public sealed class GattDeviceService : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    GattSession Session { get; }
    GattSharingMode SharingMode { get; }
    public static IAsyncOperation<GattDeviceService> FromIdAsync(string deviceId, GattSharingMode sharingMode);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync();
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(Guid characteristicUuid);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(Guid characteristicUuid, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndUuid(BluetoothDeviceId bluetoothDeviceId, Guid serviceUuid);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndUuid(BluetoothDeviceId bluetoothDeviceId, Guid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync();
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(Guid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(Guid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattOpenStatus> OpenAsync(GattSharingMode sharingMode);
    IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
  }
  public sealed class GattDeviceServicesResult
  public sealed class GattLocalCharacteristic
  public sealed class GattLocalCharacteristicParameters
  public sealed class GattLocalCharacteristicResult
  public sealed class GattLocalDescriptor
  public sealed class GattLocalDescriptorParameters
  public sealed class GattLocalDescriptorResult
  public sealed class GattLocalService
  public enum GattOpenStatus
  public sealed class GattPresentationFormat {
    public static GattPresentationFormat FromParts(byte formatType, int exponent, ushort unit, byte namespaceId, ushort description);
  }
  public static class GattProtocolError
  public sealed class GattReadClientCharacteristicConfigurationDescriptorResult {
    IReference<byte> ProtocolError { get; }
  }
  public sealed class GattReadRequest
  public sealed class GattReadRequestedEventArgs
  public sealed class GattReadResult {
    IReference<byte> ProtocolError { get; }
  }
  public sealed class GattReliableWriteTransaction {
    IAsyncOperation<GattWriteResult> CommitWithResultAsync();
  }
  public enum GattRequestState
  public sealed class GattRequestStateChangedEventArgs
  public sealed class GattServiceProvider
  public enum GattServiceProviderAdvertisementStatus
  public sealed class GattServiceProviderAdvertisementStatusChangedEventArgs
  public sealed class GattServiceProviderAdvertisingParameters
  public sealed class GattServiceProviderResult
  public sealed class GattSession : IClosable
  public enum GattSessionStatus
  public sealed class GattSessionStatusChangedEventArgs
  public enum GattSharingMode
  public sealed class GattSubscribedClient
  public sealed class GattWriteRequest
  public sealed class GattWriteRequestedEventArgs
  public sealed class GattWriteResult
}
namespace Windows.Devices.Haptics {
  public static class KnownSimpleHapticsControllerWaveforms
  public sealed class SimpleHapticsController
  public sealed class SimpleHapticsControllerFeedback
  public enum VibrationAccessStatus
  public sealed class VibrationDevice
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScanner : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public static class BarcodeSymbologies {
    public static uint Gs1DWCode { get; }
  }
  public sealed class BarcodeSymbologyAttributes
  public enum BarcodeSymbologyDecodeLengthKind
  public sealed class CashDrawer : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    IAsyncOperation<BarcodeSymbologyAttributes> GetSymbologyAttributesAsync(uint barcodeSymbology);
    IAsyncOperation<bool> SetSymbologyAttributesAsync(uint barcodeSymbology, BarcodeSymbologyAttributes attributes);
  }
  public sealed class ClaimedLineDisplay : IClosable
  public sealed class LineDisplay : IClosable
  public sealed class LineDisplayCapabilities
  public enum LineDisplayScrollDirection
  public enum LineDisplayTextAttribute
  public enum LineDisplayTextAttributeGranularity
  public sealed class LineDisplayWindow : IClosable
  public sealed class MagneticStripeReader : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public enum PosConnectionTypes : uint
  public sealed class PosPrinter : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
}
namespace Windows.Gaming.Input {
  public sealed class ArcadeStick : IGameController, IGameControllerBatteryInfo {
    public static ArcadeStick FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class FlightStick : IGameController, IGameControllerBatteryInfo
  public enum FlightStickButtons : uint
  public struct FlightStickReading
  public enum GameControllerSwitchKind
  public enum GameControllerSwitchPosition
  public sealed class Gamepad : IGameController, IGameControllerBatteryInfo {
    public static Gamepad FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class Headset : IGameControllerBatteryInfo {
    BatteryReport TryGetBatteryReport();
  }
  public interface IGameControllerBatteryInfo
  public sealed class RacingWheel : IGameController, IGameControllerBatteryInfo {
    public static RacingWheel FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class RawGameController : IGameController, IGameControllerBatteryInfo
  public sealed class UINavigationController : IGameController, IGameControllerBatteryInfo {
    public static UINavigationController FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.Gaming.Input.Custom {
  public static class GameControllerFactoryManager {
    public static IGameController TryGetFactoryControllerFromGameController(ICustomGameControllerFactory factory, IGameController gameController);
  }
  public sealed class HidGameControllerProvider : IGameControllerProvider
  public interface IHidGameControllerInputSink : IGameControllerInputSink
}
namespace Windows.Gaming.UI {
  public enum GameChatMessageOrigin
  public sealed class GameChatOverlay
  public enum GameChatOverlayPosition
}
namespace Windows.Globalization {
  public static class CurrencyIdentifiers {
    public static string BYN { get; }
  }
}
namespace Windows.Globalization.Collation {
  public sealed class CharacterGroupings : IIterable<CharacterGrouping>, IVectorView<CharacterGrouping> {
    public CharacterGroupings(string language);
  }
}
namespace Windows.Graphics {
  public struct PointInt32
  public struct RectInt32
  public struct SizeInt32
}
namespace Windows.Graphics.Display {
  public sealed class BrightnessOverride
  public enum DisplayBrightnessOverrideOptions : uint
  public enum DisplayBrightnessScenario
}
namespace Windows.Graphics.Display.Core {
  public enum HdmiDisplayColorSpace
  public struct HdmiDisplayHdr2086Metadata
  public enum HdmiDisplayHdrOption
  public sealed class HdmiDisplayInformation
  public sealed class HdmiDisplayMode
  public enum HdmiDisplayPixelEncoding
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    HolographicDisplay Display { get; }
    HolographicCameraViewportParameters LeftViewportParameters { get; }
    HolographicCameraViewportParameters RightViewportParameters { get; }
  }
  public sealed class HolographicCameraRenderingParameters {
    HolographicReprojectionMode ReprojectionMode { get; set; }
    void CommitDirect3D11DepthBuffer(IDirect3DSurface value);
  }
  public sealed class HolographicCameraViewportParameters
  public sealed class HolographicDisplay
  public enum HolographicReprojectionMode
  public sealed class HolographicSpace {
    public static bool IsAvailable { get; }
    public static bool IsSupported { get; }
    public static event EventHandler<object> IsAvailableChanged;
  }
}
namespace Windows.Management {
  public sealed class MdmAlert
  public enum MdmAlertDataType
  public enum MdmAlertMark
  public sealed class MdmSession
  public static class MdmSessionManager
  public enum MdmSessionState
}
namespace Windows.Management.Deployment {
  public enum DeploymentOptions : uint {
    RequiredContentGroupOnly = (uint)256,
  }
  public sealed class DeploymentResult {
    bool IsRegistered { get; }
  }
  public sealed class PackageManager {
    PackageManagerDebugSettings DebugSettings { get; }
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RegisterPackageByFamilyNameAsync(string mainPackageFamilyName, IIterable<string> dependencyPackageFamilyNames, DeploymentOptions deploymentOptions, PackageVolume appDataVolume, IIterable<string> optionalPackageFamilyNames);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
  }
  public sealed class PackageManagerDebugSettings
}
namespace Windows.Management.Policies {
  public static class NamedPolicy
  public sealed class NamedPolicyData
  public enum NamedPolicyKind
}
namespace Windows.Media {
  public sealed class MediaExtensionManager {
    void RegisterMediaExtensionForAppService(IMediaExtension extension, AppServiceConnection connection);
  }
  public sealed class MediaTimelineController {
    IReference<TimeSpan> Duration { get; set; }
    bool IsLoopingEnabled { get; set; }
    event TypedEventHandler<MediaTimelineController, object> Ended;
    event TypedEventHandler<MediaTimelineController, MediaTimelineControllerFailedEventArgs> Failed;
  }
  public sealed class MediaTimelineControllerFailedEventArgs
  public enum MediaTimelineControllerState {
    Error = 3,
    Stalled = 2,
  }
  public struct MediaTimeRange
}
namespace Windows.Media.Capture {
  public sealed class MediaCapture : IClosable {
    event TypedEventHandler<MediaCapture, MediaCaptureDeviceExclusiveControlStatusChangedEventArgs> CaptureDeviceExclusiveControlStatusChanged;
    IAsyncOperation<MultiSourceMediaFrameReader> CreateMultiSourceFrameReaderAsync(IIterable<MediaFrameSource> inputSources);
  }
  public enum MediaCaptureDeviceExclusiveControlStatus
  public sealed class MediaCaptureDeviceExclusiveControlStatusChangedEventArgs
  public sealed class MediaCaptureInitializationSettings {
    bool AlwaysPlaySystemShutterSound { get; set; }
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class DepthMediaFrame {
    uint MaxReliableDepth { get; }
    uint MinReliableDepth { get; }
  }
  public enum MediaFrameReaderStartStatus {
    ExclusiveControlNotAvailable = 4,
  }
  public sealed class MediaFrameSourceController {
    IAsyncOperation<MediaFrameSourceGetPropertyResult> GetPropertyByExtendedIdAsync(byte[] extendedPropertyId, IReference<uint> maxPropertyValueSize);
    IAsyncOperation<MediaFrameSourceSetPropertyStatus> SetPropertyByExtendedIdAsync(byte[] extendedPropertyId, byte[] propertyValue);
  }
  public enum MediaFrameSourceGetPropertyStatus {
    MaxPropertyValueSizeRequired = 5,
    MaxPropertyValueSizeTooSmall = 4,
  }
  public sealed class MultiSourceMediaFrameArrivedEventArgs
  public sealed class MultiSourceMediaFrameReader : IClosable
  public enum MultiSourceMediaFrameReaderStartStatus
  public sealed class MultiSourceMediaFrameReference : IClosable
}
namespace Windows.Media.Core {
  public enum AudioDecoderDegradationReason {
    SpatialAudioNotSupported = 2,
  }
  public sealed class ChapterCue : IMediaCue
  public enum CodecCategory
  public sealed class CodecInfo
  public enum CodecKind
  public sealed class CodecQuery
  public static class CodecSubtypes
  public sealed class DataCue : IMediaCue {
    PropertySet Properties { get; }
  }
  public sealed class ImageCue : IMediaCue
  public interface ITimedMetadataTrackProvider
 public sealed class MediaBindingEventArgs {
    void SetAdaptiveMediaSource(AdaptiveMediaSource mediaSource);
    void SetStorageFile(IStorageFile file);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    AdaptiveMediaSource AdaptiveMediaSource { get; }
    MediaStreamSource MediaStreamSource { get; }
    MseStreamSource MseStreamSource { get; }
    Uri Uri { get; }
    IAsyncAction OpenAsync();
  }
  public sealed class MediaStreamSource : IMediaSource {
    IReference<double> MaxSupportedPlaybackRate { get; set; }
  }
  public sealed class SpeechCue : IMediaCue
  public enum TimedMetadataKind {
    ImageSubtitle = 6,
    Speech = 7,
  }
  public enum TimedTextFontStyle
  public sealed class TimedTextSource {
    public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream);
    public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream, string defaultLanguage);
    public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri);
    public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri, string defaultLanguage);
  }
  public sealed class TimedTextStyle {
    TimedTextFontStyle FontStyle { get; set; }
    bool IsLineThroughEnabled { get; set; }
    bool IsOverlineEnabled { get; set; }
    bool IsUnderlineEnabled { get; set; }
  }
}
namespace Windows.Media.Core.Preview {
  public static class SoundLevelBroker
}
namespace Windows.Media.Devices {
  public sealed class AudioDeviceModule
  public sealed class AudioDeviceModuleNotificationEventArgs
  public sealed class AudioDeviceModulesManager
  public sealed class ModuleCommandResult
  public enum SendCommandStatus
  public sealed class VideoDeviceController : IMediaDeviceController {
    string Id { get; }
    VideoDeviceControllerGetDevicePropertyResult GetDevicePropertyByExtendedId(byte[] extendedPropertyId, IReference<uint> maxPropertyValueSize);
    VideoDeviceControllerGetDevicePropertyResult GetDevicePropertyById(string propertyId, IReference<uint> maxPropertyValueSize);
    VideoDeviceControllerSetDevicePropertyStatus SetDevicePropertyByExtendedId(byte[] extendedPropertyId, byte[] propertyValue);
    VideoDeviceControllerSetDevicePropertyStatus SetDevicePropertyById(string propertyId, object propertyValue);
  }
  public sealed class VideoDeviceControllerGetDevicePropertyResult
  public enum VideoDeviceControllerGetDevicePropertyStatus
  public enum VideoDeviceControllerSetDevicePropertyStatus
}
namespace Windows.Media.MediaProperties {
  public sealed class AudioEncodingProperties : IMediaEncodingProperties {
    bool IsSpatial { get; }
    public static AudioEncodingProperties CreateAlac(uint sampleRate, uint channelCount, uint bitsPerSample);
    public static AudioEncodingProperties CreateFlac(uint sampleRate, uint channelCount, uint bitsPerSample);
  }
  public sealed class MediaEncodingProfile {
    public static MediaEncodingProfile CreateAlac(AudioEncodingQuality quality);
    public static MediaEncodingProfile CreateFlac(AudioEncodingQuality quality);
    public static MediaEncodingProfile CreateHevc(VideoEncodingQuality quality);
  }
  public static class MediaEncodingSubtypes {
    public static string Alac { get; }
    public static string D16 { get; }
    public static string Flac { get; }
    public static string L16 { get; }
    public static string L8 { get; }
    public static string Vp9 { get; }
  }
  public enum SphericalVideoFrameFormat
 public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    SphericalVideoFrameFormat SphericalVideoFrameFormat { get; }
    public static VideoEncodingProperties CreateHevc();
  }
  public enum VideoEncodingQuality {
    Uhd2160p = 8,
    Uhd4320p = 9,
  }
}
namespace Windows.Media.Playback {
  public enum AutoLoadedDisplayPropertyKind
  public sealed class CurrentMediaPlaybackItemChangedEventArgs {
    MediaPlaybackItemChangedReason Reason { get; }
  }
  public sealed class MediaPlaybackItem : IMediaPlaybackSource {
    AutoLoadedDisplayPropertyKind AutoLoadedDisplayProperties { get; set; }
    bool IsDisabledInPlaybackList { get; set; }
    double TotalDownloadProgress { get; }
  }
  public enum MediaPlaybackItemChangedReason
  public sealed class MediaPlaybackList : IMediaPlaybackSource {
    IReference<uint> MaxPlayedItemsToKeepOpen { get; set; }
  }
  public sealed class MediaPlaybackSession {
    bool IsMirroring { get; set; }
    MediaPlaybackSphericalVideoProjection SphericalVideoProjection { get; }
    event TypedEventHandler<MediaPlaybackSession, object> BufferedRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> PlayedRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> SeekableRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> SupportedPlaybackRatesChanged;
    IVectorView<MediaTimeRange> GetBufferedRanges();
    IVectorView<MediaTimeRange> GetPlayedRanges();
    IVectorView<MediaTimeRange> GetSeekableRanges();
    bool IsSupportedPlaybackRateRange(double rate1, double rate2);
  }
  public sealed class MediaPlaybackSphericalVideoProjection
  public sealed class MediaPlayer : IClosable {
    bool IsVideoFrameServerEnabled { get; set; }
    event TypedEventHandler<MediaPlayer, object> VideoFrameAvailable;
    void CopyFrameToStereoscopicVideoSurfaces(IDirect3DSurface destinationLeftEye, IDirect3DSurface destinationRightEye);
    void CopyFrameToVideoSurface(IDirect3DSurface destination);
    void CopyFrameToVideoSurface(IDirect3DSurface destination, Rect targetRectangle);
  }
  public enum SphericalVideoProjectionMode
}
namespace Windows.Media.Protection.PlayReady {
  public interface IPlayReadyLicenseSession2 : IPlayReadyLicenseSession
  public sealed class PlayReadyLicense : IPlayReadyLicense {
    bool ExpiresInRealTime { get; }
    bool InMemoryOnly { get; }
    Guid SecureStopId { get; }
    uint SecurityLevel { get; }
  }
  public sealed class PlayReadyLicenseAcquisitionServiceRequest : IMediaProtectionServiceRequest, IPlayReadyLicenseAcquisitionServiceRequest, IPlayReadyServiceRequest {
    PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
  }
  public sealed class PlayReadyLicenseSession : IPlayReadyLicenseSession, IPlayReadyLicenseSession2 {
    PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
  }
}
namespace Windows.Media.SpeechSynthesis {
  public sealed class SpeechSynthesisStream : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType, ITimedMetadataTrackProvider {
    IVectorView<TimedMetadataTrack> TimedMetadataTracks { get; }
  }
  public sealed class SpeechSynthesizer : IClosable {
    SpeechSynthesizerOptions Options { get; }
  }
  public sealed class SpeechSynthesizerOptions
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSource : IClosable, IMediaSource {
    IReference<TimeSpan> DesiredSeekableWindowSize { get; set; }
    AdaptiveMediaSourceDiagnostics Diagnostics { get; }
    IReference<TimeSpan> MaxSeekableWindowSize { get; }
    IReference<TimeSpan> MinLiveOffset { get; }
    void Close();
    AdaptiveMediaSourceCorrelatedTimes GetCorrelatedTimes();
  }
  public sealed class AdaptiveMediaSourceCorrelatedTimes
  public sealed class AdaptiveMediaSourceCreationResult {
    HResult ExtendedError { get; }
  }
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs
  public sealed class AdaptiveMediaSourceDiagnostics
  public enum AdaptiveMediaSourceDiagnosticType
  public sealed class AdaptiveMediaSourceDownloadBitrateChangedEventArgs {
    AdaptiveMediaSourceDownloadBitrateChangedReason Reason { get; }
  }
  public enum AdaptiveMediaSourceDownloadBitrateChangedReason
  public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
    IReference<TimeSpan> Position { get; }
    int RequestId { get; }
    AdaptiveMediaSourceDownloadStatistics Statistics { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
    HResult ExtendedError { get; }
    IReference<TimeSpan> Position { get; }
    int RequestId { get; }
    AdaptiveMediaSourceDownloadStatistics Statistics { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
    IReference<TimeSpan> Position { get; }
    int RequestId { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadStatistics
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAccount {
    Uri AccountExperienceUrl { get; }
  }
  public sealed class MobileBroadbandDeviceInformation {
    string SimGid1 { get; }
    string SimPnn { get; }
    string SimSpn { get; }
  }
}
namespace Windows.Networking.PushNotifications {
  public static class PushNotificationChannelManager {
    public static PushNotificationChannelManagerForUser GetDefault();
  }
  public sealed class PushNotificationChannelManagerForUser {
    IAsyncOperation<PushNotificationChannel> CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(IBuffer appServerKey, string channelId);
    IAsyncOperation<PushNotificationChannel> CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(IBuffer appServerKey, string channelId, string appId);
  }
  public sealed class RawNotification {
    string ChannelId { get; }
    IMapView<string, string> Headers { get; }
  }
}
namespace Windows.Perception.Spatial {
  public sealed class SpatialEntity
  public sealed class SpatialEntityAddedEventArgs
  public sealed class SpatialEntityRemovedEventArgs
  public sealed class SpatialEntityStore
  public sealed class SpatialEntityUpdatedEventArgs
  public sealed class SpatialEntityWatcher
  public enum SpatialEntityWatcherStatus
  public enum SpatialLookDirectionRange
  public enum SpatialMovementRange
  public sealed class SpatialStageFrameOfReference
}
namespace Windows.Perception.Spatial.Surfaces {
  public sealed class SpatialSurfaceObserver {
    public static bool IsSupported();
  }
}
namespace Windows.Security.Authentication.Identity.Provider {
  public enum SecondaryAuthenticationFactorAuthenticationStage {
    CheckingDevicePresence = 8,
  }
  public enum SecondaryAuthenticationFactorDeviceCapabilities : uint {
    CloseRangeDataTransmission = (uint)64,
  }
  public enum SecondaryAuthenticationFactorDevicePresence
  public enum SecondaryAuthenticationFactorDevicePresenceMonitoringMode
  public enum SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus
  public sealed class SecondaryAuthenticationFactorInfo {
    bool IsAuthenticationSupported { get; }
    SecondaryAuthenticationFactorDevicePresenceMonitoringMode PresenceMonitoringMode { get; }
    IAsyncAction UpdateDevicePresenceAsync(SecondaryAuthenticationFactorDevicePresence presenceState);
  }
  public sealed class SecondaryAuthenticationFactorRegistration {
    public static bool IsDevicePresenceMonitoringSupported();
    public static IAsyncOperation<SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus> RegisterDevicePresenceMonitoringAsync(string deviceId, string deviceInstancePath, SecondaryAuthenticationFactorDevicePresenceMonitoringMode monitoringMode);
    public static IAsyncOperation<SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus> RegisterDevicePresenceMonitoringAsync(string deviceId, string deviceInstancePath, SecondaryAuthenticationFactorDevicePresenceMonitoringMode monitoringMode, string deviceFriendlyName, string deviceModelNumber, IBuffer deviceConfigurationData);
    public static IAsyncAction UnregisterDevicePresenceMonitoringAsync(string deviceId);
  }
}
namespace Windows.Security.Authentication.OnlineId {
  public static class OnlineIdSystemAuthenticator
  public sealed class OnlineIdSystemAuthenticatorForUser
  public sealed class OnlineIdSystemIdentity
  public sealed class OnlineIdSystemTicketResult
  public enum OnlineIdSystemTicketStatus
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class WebTokenRequest {
    string CorrelationId { get; set; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public interface IWebAccountProviderTokenObjects2 : IWebAccountProviderTokenObjects
  public static class WebAccountManager {
    public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props);
    public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props, WebAccountScope scope);
    public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props, WebAccountScope scope, string perUserWebAccountId);
    public static IAsyncOperation<IVectorView<WebAccount>> FindAllProviderWebAccountsForUserAsync(User user);
  }
  public sealed class WebAccountProviderTriggerDetails : IWebAccountProviderTokenObjects, IWebAccountProviderTokenObjects2 {
    User User { get; }
  }
}
namespace Windows.Security.Cryptography.Certificates {
  public sealed class CertificateExtension
  public sealed class CertificateRequestProperties {
    IVector<CertificateExtension> Extensions { get; }
    SubjectAlternativeNameInfo SubjectAlternativeName { get; }
    IVector<string> SuppressedDefaults { get; }
  }
  public sealed class SubjectAlternativeNameInfo {
    IVector<string> DistinguishedNames { get; }
    IVector<string> DnsNames { get; }
    IVector<string> EmailNames { get; }
    CertificateExtension Extension { get; }
    IVector<string> IPAddresses { get; }
    IVector<string> PrincipalNames { get; }
    IVector<string> Urls { get; }
  }
}
namespace Windows.Services.Cortana {
  public enum CortanaPermission
  public enum CortanaPermissionsChangeResult
  public sealed class CortanaPermissionsManager
}
namespace Windows.Services.Maps {
  public sealed class EnhancedWaypoint
  public sealed class ManeuverWarning
  public enum ManeuverWarningKind
  public enum ManeuverWarningSeverity
  public sealed class MapRoute {
    TimeSpan DurationWithoutTraffic { get; }
    TrafficCongestion TrafficCongestion { get; }
  }
  public static class MapRouteFinder {
    public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints);
    public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints, MapRouteDrivingOptions options);
  }
  public sealed class MapRouteLeg {
    TimeSpan DurationWithoutTraffic { get; }
    TrafficCongestion TrafficCongestion { get; }
  }
  public sealed class MapRouteManeuver {
    IVectorView<ManeuverWarning> Warnings { get; }
  }
  public static class MapService {
    public static MapServiceDataUsagePreference DataUsagePreference { get; set; }
  }
  public enum MapServiceDataUsagePreference
  public enum TrafficCongestion
  public enum WaypointKind
}
namespace Windows.Services.Maps.OfflineMaps {
  public sealed class OfflineMapPackage
  public sealed class OfflineMapPackageQueryResult
  public enum OfflineMapPackageQueryStatus
  public sealed class OfflineMapPackageStartDownloadResult
  public enum OfflineMapPackageStartDownloadStatus
  public enum OfflineMapPackageStatus
}
namespace Windows.Storage {
  public enum KnownFolderId {
    AllAppMods = 14,
    CurrentAppMods = 15,
  }
  public sealed class StorageLibrary {
    IAsyncOperation<bool> AreFolderSuggestionsAvailableAsync();
  }
  public enum StorageOpenOptions : uint {
    AllowReadersAndWriters = (uint)2,
  }
}
namespace Windows.System {
  public sealed class AppDiagnosticInfo
  public sealed class LauncherOptions : ILauncherViewOptions {
    bool LimitPickerToCurrentAppAndAppUriHandlers { get; set; }
  }
}
namespace Windows.System.Diagnostics {
  public sealed class SystemCpuUsage
  public sealed class SystemCpuUsageReport
  public sealed class SystemDiagnosticInfo
  public sealed class SystemMemoryUsage
  public sealed class SystemMemoryUsageReport
}
namespace Windows.System.Diagnostics.DevicePortal {
  public sealed class DevicePortalConnection
  public sealed class DevicePortalConnectionClosedEventArgs
  public enum DevicePortalConnectionClosedReason
  public sealed class DevicePortalConnectionRequestReceivedEventArgs
}
namespace Windows.System.Diagnostics.Telemetry {
  public static class PlatformTelemetryClient
  public sealed class PlatformTelemetryRegistrationResult
  public sealed class PlatformTelemetryRegistrationSettings
  public enum PlatformTelemetryRegistrationStatus
}
namespace Windows.System.Diagnostics.TraceReporting {
  public static class PlatformDiagnosticActions
  public enum PlatformDiagnosticActionState
  public enum PlatformDiagnosticEscalationType
  public enum PlatformDiagnosticEventBufferLatencies : uint
  public sealed class PlatformDiagnosticTraceInfo
  public enum PlatformDiagnosticTracePriority
  public sealed class PlatformDiagnosticTraceRuntimeInfo
  public enum PlatformDiagnosticTraceSlotState
  public enum PlatformDiagnosticTraceSlotType
}
namespace Windows.System.Profile {
  public static class EducationSettings
}
namespace Windows.System.RemoteSystems {
  public static class KnownRemoteSystemCapabilities
  public sealed class RemoteSystem {
    bool IsAvailableBySpatialProximity { get; }
    IAsyncOperation<bool> GetCapabilitySupportedAsync(string capabilityName);
    public static bool IsAuthorizationKindEnabled(RemoteSystemAuthorizationKind kind);
  }
  public enum RemoteSystemAuthorizationKind
  public sealed class RemoteSystemAuthorizationKindFilter : IRemoteSystemFilter
  public enum RemoteSystemDiscoveryType {
    SpatiallyProximal = 3,
  }
  public sealed class RemoteSystemSession : IClosable
  public sealed class RemoteSystemSessionAddedEventArgs
  public sealed class RemoteSystemSessionController
  public sealed class RemoteSystemSessionCreationResult
  public enum RemoteSystemSessionCreationStatus
  public sealed class RemoteSystemSessionDisconnectedEventArgs
  public enum RemoteSystemSessionDisconnectedReason
  public sealed class RemoteSystemSessionInfo
  public sealed class RemoteSystemSessionInvitation
  public sealed class RemoteSystemSessionInvitationListener
  public sealed class RemoteSystemSessionInvitationReceivedEventArgs
  public sealed class RemoteSystemSessionJoinRequest
  public sealed class RemoteSystemSessionJoinRequestedEventArgs
  public sealed class RemoteSystemSessionJoinResult
  public enum RemoteSystemSessionJoinStatus
  public sealed class RemoteSystemSessionMessageChannel
  public enum RemoteSystemSessionMessageChannelReliability
  public sealed class RemoteSystemSessionOptions
  public sealed class RemoteSystemSessionParticipant
  public sealed class RemoteSystemSessionParticipantAddedEventArgs
  public sealed class RemoteSystemSessionParticipantRemovedEventArgs
  public sealed class RemoteSystemSessionParticipantWatcher
  public enum RemoteSystemSessionParticipantWatcherStatus
  public sealed class RemoteSystemSessionRemovedEventArgs
  public sealed class RemoteSystemSessionUpdatedEventArgs
  public sealed class RemoteSystemSessionValueSetReceivedEventArgs
  public sealed class RemoteSystemSessionWatcher
  public enum RemoteSystemSessionWatcherStatus
}
namespace Windows.System.UserProfile {
  public sealed class FeedbackAndDiagnosticsSettings
}
namespace Windows.UI {
  public sealed class ColorHelper {
    public static string ToDisplayName(Color color);
  }
}
namespace Windows.UI.Composition {
  public enum AnimationDelayBehavior
  public sealed class CompositionCapabilities
  public class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
    SizeInt32 SizeInt32 { get; }
    void Resize(SizeInt32 sizePixels);
    void Scroll(PointInt32 offset);
    void Scroll(PointInt32 offset, RectInt32 scrollRect);
    void ScrollWithClip(PointInt32 offset, RectInt32 clipRect);
    void ScrollWithClip(PointInt32 offset, RectInt32 clipRect, RectInt32 scrollRect);
  }
  public sealed class CompositionGraphicsDevice : CompositionObject {
    CompositionDrawingSurface CreateDrawingSurface2(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
   CompositionVirtualDrawingSurface CreateVirtualDrawingSurface(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
  }
  public class CompositionVirtualDrawingSurface : CompositionDrawingSurface
  public sealed class Compositor : IClosable {
    CompositionBackdropBrush CreateHostBackdropBrush();
  }
  public class KeyFrameAnimation : CompositionAnimation {
    AnimationDelayBehavior DelayBehavior { get; set; }
  }
  public class Visual : CompositionObject {
    Visual ParentForTransform { get; set; }
    Vector3 RelativeOffsetAdjustment { get; set; }
    Vector2 RelativeSizeAdjustment { get; set; }
  }
}
namespace Windows.UI.Composition.Interactions {
  public sealed class CompositionConditionalValue : CompositionObject
  public sealed class InteractionTracker : CompositionObject {
    void ConfigureCenterPointXInertiaModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureCenterPointYInertiaModifiers(IIterable<CompositionConditionalValue> conditionalValues);
  }
  public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
    Vector3 DeltaPosition { get; }
    float DeltaScale { get; }
    Vector3 Position { get; }
    Vector3 PositionVelocity { get; }
    float Scale { get; }
    float ScaleVelocity { get; }
    void ConfigureCenterPointXModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureCenterPointYModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureDeltaPositionXModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureDeltaPositionYModifiers(IIterable<CompositionConditionalValue> conditionalValues);
    void ConfigureDeltaScaleModifiers(IIterable<CompositionConditionalValue> conditionalValues);
  }
}
namespace Windows.UI.Core {
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    event TypedEventHandler<CoreWindow, object> ResizeCompleted;
    event TypedEventHandler<CoreWindow, object> ResizeStarted;
  }
  public sealed class SystemNavigationCloseRequestedEventArgs
  public sealed class SystemNavigationManager {
    event TypedEventHandler<SystemNavigationManager, SystemNavigationCloseRequestedEventArgs> CloseRequested;
  }
}
namespace Windows.UI.Input {
  public sealed class RadialController {
    event TypedEventHandler<RadialController, RadialControllerButtonHoldingEventArgs> ButtonHolding;
    event TypedEventHandler<RadialController, RadialControllerButtonPressedEventArgs> ButtonPressed;
    event TypedEventHandler<RadialController, RadialControllerButtonReleasedEventArgs> ButtonReleased;
  }
  public sealed class RadialControllerButtonClickedEventArgs {
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerButtonHoldingEventArgs
  public sealed class RadialControllerButtonPressedEventArgs
  public sealed class RadialControllerButtonReleasedEventArgs
  public sealed class RadialControllerConfiguration {
    RadialController ActiveControllerWhenMenuIsSuppressed { get; set; }
    bool IsMenuSuppressed { get; set; }
  }
  public sealed class RadialControllerControlAcquiredEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerMenuItem {
    public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily);
    public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily, Uri fontUri);
  }
  public sealed class RadialControllerRotationChangedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerScreenContactContinuedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerScreenContactEndedEventArgs
  public sealed class RadialControllerScreenContactStartedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
}
namespace Windows.UI.Input.Core {
  public sealed class RadialControllerIndependentInputSource
}
namespace Windows.UI.Input.Inking {
  public sealed class InkDrawingAttributes {
    bool IgnoreTilt { get; set; }
  }
  public enum InkHighContrastAdjustment
  public enum InkPersistenceFormat
  public sealed class InkPoint {
    public InkPoint(Point position, float pressure, float tiltX, float tiltY, ulong timestamp);
    float TiltX { get; }
    float TiltY { get; }
    ulong Timestamp { get; }
  }
  public sealed class InkPresenter {
    InkHighContrastAdjustment HighContrastAdjustment { get; set; }
  }
  public sealed class InkPresenterProtractor : IInkPresenterStencil
  public sealed class InkPresenterRuler : IInkPresenterStencil {
    bool AreTickMarksVisible { get; set; }
    bool IsCompassVisible { get; set; }
  }
  public enum InkPresenterStencilKind {
    Protractor = 2,
  }
  public sealed class InkStroke {
    uint Id { get; }
    IReference<TimeSpan> StrokeDuration { get; set; }
    IReference<DateTime> StrokeStartedTime { get; set; }
  }
  public sealed class InkStrokeBuilder {
    InkStroke CreateStrokeFromInkPoints(IIterable<InkPoint> inkPoints, Matrix3x2 transform, IReference<DateTime> strokeStartedTime, IReference<TimeSpan> strokeDuration);
  }
  public sealed class InkStrokeContainer : IInkStrokeContainer {
    InkStroke GetStrokeById(uint id);
    IAsyncOperationWithProgress<uint, uint> SaveAsync(IOutputStream outputStream, InkPersistenceFormat inkPersistenceFormat);
  }
}
namespace Windows.UI.Input.Inking.Analysis {
  public interface IInkAnalysisNode
  public interface IInkAnalyzerFactory
  public enum InkAnalysisDrawingKind
  public sealed class InkAnalysisInkBullet : IInkAnalysisNode
  public sealed class InkAnalysisInkDrawing : IInkAnalysisNode
  public sealed class InkAnalysisInkWord : IInkAnalysisNode
  public sealed class InkAnalysisLine : IInkAnalysisNode
  public sealed class InkAnalysisListItem : IInkAnalysisNode
  public sealed class InkAnalysisNode : IInkAnalysisNode
  public enum InkAnalysisNodeKind
  public sealed class InkAnalysisParagraph : IInkAnalysisNode
  public sealed class InkAnalysisResult
  public sealed class InkAnalysisRoot : IInkAnalysisNode
  public enum InkAnalysisStatus
  public enum InkAnalysisStrokeKind
  public sealed class InkAnalysisWritingRegion : IInkAnalysisNode
  public sealed class InkAnalyzer
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController
  public sealed class SpatialInteractionControllerProperties
  public sealed class SpatialInteractionDetectedEventArgs {
    SpatialInteractionSource InteractionSource { get; }
  }
  public enum SpatialInteractionPressKind
  public sealed class SpatialInteractionSource {
    SpatialInteractionController Controller { get; }
    bool IsGraspSupported { get; }
    bool IsMenuSupported { get; }
    bool IsPointingSupported { get; }
    SpatialInteractionSourceState TryGetStateAtTimestamp(PerceptionTimestamp timestamp);
  }
  public sealed class SpatialInteractionSourceEventArgs {
    SpatialInteractionPressKind PressKind { get; }
  }
  public sealed class SpatialInteractionSourceState {
    SpatialInteractionControllerProperties ControllerProperties { get; }
    bool IsGrasped { get; }
    bool IsMenuPressed { get; }
    bool IsSelectPressed { get; }
    double SelectPressedValue { get; }
  }
  public sealed class SpatialPointerInteractionSourcePose
  public sealed class SpatialPointerPose {
    SpatialPointerInteractionSourcePose TryGetInteractionSourcePose(SpatialInteractionSource source);
  }
}
namespace Windows.UI.Notifications {
  public sealed class NotificationData
  public enum NotificationUpdateResult
  public sealed class ToastCollection
  public sealed class ToastCollectionManager
  public sealed class ToastNotification {
    NotificationData Data { get; set; }
  }
  public sealed class ToastNotificationHistoryChangedTriggerDetail {
    string CollectionId { get; }
  }
  public static class ToastNotificationManager {
    public static ToastNotificationManagerForUser GetDefault();
  }
  public sealed class ToastNotificationManagerForUser {
    IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionIdAsync(string collectionId);
    ToastCollectionManager GetToastCollectionManager();
    ToastCollectionManager GetToastCollectionManager(string appId);
    IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionIdAsync(string collectionId);
  }
  public sealed class ToastNotifier {
    NotificationUpdateResult Update(NotificationData data, string tag);
    NotificationUpdateResult Update(NotificationData data, string tag, string group);
  }
}
namespace Windows.UI.StartScreen {
  public sealed class StartScreenManager
}
namespace Windows.UI.Text {
  public sealed class RichEditTextDocument : ITextDocument
  public enum TextDecorations : uint
  public enum TextGetOptions : uint {
    UseLf = (uint)16777216,
  }
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationView {
    ApplicationViewMode ViewMode { get; }
    bool IsViewModeSupported(ApplicationViewMode viewMode);
    IAsyncOperation<bool> TryConsolidateAsync();
    IAsyncOperation<bool> TryEnterViewModeAsync(ApplicationViewMode viewMode);
    IAsyncOperation<bool> TryEnterViewModeAsync(ApplicationViewMode viewMode, ViewModePreferences viewModePreferences);
  }
  public sealed class ApplicationViewConsolidatedEventArgs {
    bool IsAppInitiated { get; }
  }
  public enum ApplicationViewMode
  public static class ApplicationViewSwitcher {
    public static IAsyncOperation<bool> TryShowAsViewModeAsync(int viewId, ApplicationViewMode viewMode);
    public static IAsyncOperation<bool> TryShowAsViewModeAsync(int viewId, ApplicationViewMode viewMode, ViewModePreferences viewModePreferences);
  }
  public sealed class UISettings {
    bool AdvancedEffectsEnabled { get; }
    event TypedEventHandler<UISettings, object> AdvancedEffectsEnabledChanged;
  }
  public sealed class ViewModePreferences
  public enum ViewSizePreference {
    Custom = 6,
  }
}
namespace Windows.UI.WebUI {
  public sealed class WebUIContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
  public sealed class WebUILockScreenComponentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral
  public sealed class WebUIPrintWorkflowForegroundTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral
}
namespace Windows.UI.Xaml {
  public class Application {
    ApplicationHighContrastAdjustment HighContrastAdjustment { get; set; }
  }
  public enum ApplicationHighContrastAdjustment : uint
  public sealed class BringIntoViewOptions
  public enum ElementHighContrastAdjustment : uint
  public class FrameworkElement : UIElement {
    public static void DeferTree(DependencyObject element);
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent GettingFocusEvent { get; }
    ElementHighContrastAdjustment HighContrastAdjustment { get; set; }
    public static DependencyProperty HighContrastAdjustmentProperty { get; }
    double KeyTipHorizontalOffset { get; set; }
    public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
    KeyTipPlacementMode KeyTipPlacementMode { get; set; }
    public static DependencyProperty KeyTipPlacementModeProperty { get; }
    double KeyTipVerticalOffset { get; set; }
    public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
    IVector<XamlLight> Lights { get; }
    public static DependencyProperty LightsProperty { get; }
    public static RoutedEvent LosingFocusEvent { get; }
    public static RoutedEvent NoFocusCandidateFoundEvent { get; }
    KeyboardNavigationMode TabFocusNavigation { get; set; }
    public static DependencyProperty TabFocusNavigationProperty { get; }
    XYFocusNavigationStrategy XYFocusDownNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusDownNavigationStrategyProperty { get; }
    XYFocusKeyboardNavigationMode XYFocusKeyboardNavigation { get; set; }
    public static DependencyProperty XYFocusKeyboardNavigationProperty { get; }
    XYFocusNavigationStrategy XYFocusLeftNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusLeftNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusRightNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusRightNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusUpNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusUpNavigationStrategyProperty { get; }
    event TypedEventHandler<UIElement, GettingFocusEventArgs> GettingFocus;
    event TypedEventHandler<UIElement, LosingFocusEventArgs> LosingFocus;
    event TypedEventHandler<UIElement, NoFocusCandidateFoundEventArgs> NoFocusCandidateFound;
    void StartBringIntoView();
    void StartBringIntoView(BringIntoViewOptions options);
  }
  public sealed class Window {
    Compositor Compositor { get; }
  }
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty CultureProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty CultureProperty { get; }
    public static int GetCulture(DependencyObject element);
    public static void SetCulture(DependencyObject element, int value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public class AutomationPeer : DependencyObject {
    int GetCulture();
    virtual int GetCultureCore();
  }
  public sealed class MapControlAutomationPeer : FrameworkElementAutomationPeer, IScrollProvider, ITransformProvider, ITransformProvider2 {
    bool CanMove { get; }
    bool CanResize { get; }
    bool CanRotate { get; }
    bool CanZoom { get; }
    double MaxZoom { get; }
    double MinZoom { get; }
    double ZoomLevel { get; }
    void Move(double x, double y);
    void Resize(double width, double height);
    void Rotate(double degrees);
    void Zoom(double zoom);
    void ZoomByUnit(ZoomUnit zoomUnit);
  }
}
namespace Windows.UI.Xaml.Controls {
  public class BitmapIcon : IconElement {
    bool ShowAsMonochrome { get; set; }
    public static DependencyProperty ShowAsMonochromeProperty { get; }
  }
  public class ComboBox : Selector {
    ComboBoxSelectionChangedTrigger SelectionChangedTrigger { get; set; }
    public static DependencyProperty SelectionChangedTriggerProperty { get; }
  }
  public enum ComboBoxSelectionChangedTrigger
  public class ContentDialog : ContentControl {
    ICommand CloseButtonCommand { get; set; }
    object CloseButtonCommandParameter { get; set; }
    public static DependencyProperty CloseButtonCommandParameterProperty { get; }
    public static DependencyProperty CloseButtonCommandProperty { get; }
    Style CloseButtonStyle { get; set; }
    public static DependencyProperty CloseButtonStyleProperty { get; }
    string CloseButtonText { get; set; }
    public static DependencyProperty CloseButtonTextProperty { get; }
    ContentDialogButton DefaultButton { get; set; }
    public static DependencyProperty DefaultButtonProperty { get; }
    Style PrimaryButtonStyle { get; set; }
    public static DependencyProperty PrimaryButtonStyleProperty { get; }
    Style SecondaryButtonStyle { get; set; }
    public static DependencyProperty SecondaryButtonStyleProperty { get; }
    event TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> CloseButtonClick;
  }
  public enum ContentDialogButton
  public class Control : FrameworkElement {
    Uri DefaultStyleResourceUri { get; set; }
    public static DependencyProperty DefaultStyleResourceUriProperty { get; }
    public static DependencyProperty IsTemplateKeyTipTargetProperty { get; }
    public static bool GetIsTemplateKeyTipTarget(DependencyObject element);
    public static void SetIsTemplateKeyTipTarget(DependencyObject element, bool value);
  }
  public sealed class FocusEngagedEventArgs : RoutedEventArgs {
    bool Handled { get; set; }
  }
  public class Frame : ContentControl, INavigate {
    void SetNavigationState(string navigationState, bool suppressNavigate);
  }
  public class InkToolbar : Control {
    InkToolbarButtonFlyoutPlacement ButtonFlyoutPlacement { get; set; }
    public static DependencyProperty ButtonFlyoutPlacementProperty { get; }
    bool IsStencilButtonChecked { get; set; }
    public static DependencyProperty IsStencilButtonCheckedProperty { get; }
    Orientation Orientation { get; set; }
    public static DependencyProperty OrientationProperty { get; }
    event TypedEventHandler<InkToolbar, InkToolbarIsStencilButtonCheckedChangedEventArgs> IsStencilButtonCheckedChanged;
    InkToolbarMenuButton GetMenuButton(InkToolbarMenuKind menu);
  }
  public enum InkToolbarButtonFlyoutPlacement
  public class InkToolbarEraserButton : InkToolbarToolButton {
    bool IsClearAllVisible { get; set; }
    public static DependencyProperty IsClearAllVisibleProperty { get; }
  }
  public class InkToolbarFlyoutItem : ButtonBase
  public enum InkToolbarFlyoutItemKind
  public sealed class InkToolbarIsStencilButtonCheckedChangedEventArgs
  public class InkToolbarMenuButton : ToggleButton
  public enum InkToolbarMenuKind
  public class InkToolbarStencilButton : InkToolbarMenuButton
  public enum InkToolbarStencilKind
  public class ListViewBase : Selector, ISemanticZoomInformation {
    ConnectedAnimation PrepareConnectedAnimation(string key, object item, string elementName);
    IAsyncOperation<bool> TryStartConnectedAnimationAsync(ConnectedAnimation animation, object item, string elementName);
  }
  public class MenuFlyoutItem : MenuFlyoutItemBase {
    IconElement Icon { get; set; }
    public static DependencyProperty IconProperty { get; }
  }
  public sealed class MenuFlyoutSubItem : MenuFlyoutItemBase {
    IconElement Icon { get; set; }
    public static DependencyProperty IconProperty { get; }
  }
  public class RichEditBox : Control {
    int MaxLength { get; set; }
    public static DependencyProperty MaxLengthProperty { get; }
    SolidColorBrush SelectionHighlightColorWhenNotFocused { get; set; }
    public static DependencyProperty SelectionHighlightColorWhenNotFocusedProperty { get; }
  }
  public sealed class RichEditBoxTextChangingEventArgs {
    bool IsContentChanging { get; }
  }
  public sealed class RichTextBlock : FrameworkElement {
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
  }
  public sealed class TextBlock : FrameworkElement {
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
  }
  public class TextBox : Control {
    SolidColorBrush SelectionHighlightColorWhenNotFocused { get; set; }
    public static DependencyProperty SelectionHighlightColorWhenNotFocusedProperty { get; }
  }
  public sealed class TextBoxTextChangingEventArgs {
    bool IsContentChanging { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapBillboard : MapElement
  public sealed class MapContextRequestedEventArgs
  public sealed class MapControl : Control {
    MapProjection MapProjection { get; set; }
    public static DependencyProperty MapProjectionProperty { get; }
    MapStyleSheet StyleSheet { get; set; }
    public static DependencyProperty StyleSheetProperty { get; }
    Thickness ViewPadding { get; set; }
    public static DependencyProperty ViewPaddingProperty { get; }
    event TypedEventHandler<MapControl, MapContextRequestedEventArgs> MapContextRequested;
    IVectorView<MapElement> FindMapElementsAtOffset(Point offset, double radius);
    void GetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
    void StartContinuousPan(double horizontalPixelsPerSecond, double verticalPixelsPerSecond);
    void StopContinuousPan();
    IAsyncOperation<bool> TryPanAsync(double horizontalPixels, double verticalPixels);
    IAsyncOperation<bool> TryPanToAsync(Geopoint location);
  }
  public enum MapProjection
  public enum MapStyle {
    Custom = 7,
  }
  public sealed class MapStyleSheet : DependencyObject
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class FlyoutBase : DependencyObject {
    DependencyObject OverlayInputPassThroughElement { get; set; }
    public static DependencyProperty OverlayInputPassThroughElementProperty { get; }
  }
}
namespace Windows.UI.Xaml.Documents {
  public sealed class Hyperlink : Span {
    FocusState FocusState { get; }
    public static DependencyProperty FocusStateProperty { get; }
    XYFocusNavigationStrategy XYFocusDownNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusDownNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusLeftNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusLeftNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusRightNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusRightNavigationStrategyProperty { get; }
    XYFocusNavigationStrategy XYFocusUpNavigationStrategy { get; set; }
    public static DependencyProperty XYFocusUpNavigationStrategyProperty { get; }
    event RoutedEventHandler GotFocus;
    event RoutedEventHandler LostFocus;
    bool Focus(FocusState value);
  }
  public class TextElement : DependencyObject {
    DependencyObject AccessKeyScopeOwner { get; set; }
    public static DependencyProperty AccessKeyScopeOwnerProperty { get; }
    bool IsAccessKeyScope { get; set; }
    public static DependencyProperty IsAccessKeyScopeProperty { get; }
    double KeyTipHorizontalOffset { get; set; }
    public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
    KeyTipPlacementMode KeyTipPlacementMode { get; set; }
    public static DependencyProperty KeyTipPlacementModeProperty { get; }
    double KeyTipVerticalOffset { get; set; }
    public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
    event TypedEventHandler<TextElement, AccessKeyDisplayDismissedEventArgs> AccessKeyDisplayDismissed;
    event TypedEventHandler<TextElement, AccessKeyDisplayRequestedEventArgs> AccessKeyDisplayRequested;
    event TypedEventHandler<TextElement, AccessKeyInvokedEventArgs> AccessKeyInvoked;
  }
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class ElementCompositionPreview {
    public static CompositionPropertySet GetPointerPositionPropertySet(UIElement targetElement);
    public static void SetImplicitHideAnimation(UIElement element, ICompositionAnimationBase animation);
    public static void SetImplicitShowAnimation(UIElement element, ICompositionAnimationBase animation);
    public static void SetIsTranslationEnabled(UIElement element, bool value);
  }
}
namespace Windows.UI.Xaml.Input {
  public sealed class AccessKeyManager {
    public static bool AreKeyTipsEnabled { get; set; }
  }
  public sealed class FindNextElementOptions
  public enum FocusInputDeviceKind
  public sealed class FocusManager {
    public static DependencyObject FindFirstFocusableElement(DependencyObject searchScope);
    public static DependencyObject FindLastFocusableElement(DependencyObject searchScope);
    public static DependencyObject FindNextElement(FocusNavigationDirection focusNavigationDirection);
    public static DependencyObject FindNextElement(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
    public static bool TryMoveFocus(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
  }
  public sealed class GettingFocusEventArgs : RoutedEventArgs
  public enum KeyTipPlacementMode
  public sealed class LosingFocusEventArgs : RoutedEventArgs
  public sealed class NoFocusCandidateFoundEventArgs : RoutedEventArgs
  public enum XYFocusKeyboardNavigationMode
  public enum XYFocusNavigationStrategy
  public enum XYFocusNavigationStrategyOverride
}
namespace Windows.UI.Xaml.Markup {
  public sealed class XamlMarkupHelper
}
namespace Windows.UI.Xaml.Media {
  public sealed class LoadedImageSourceLoadCompletedEventArgs
  public enum LoadedImageSourceLoadStatus
  public sealed class LoadedImageSurface : IClosable, ICompositionSurface
  public class XamlCompositionBrushBase : Brush
  public class XamlLight : DependencyObject
}
namespace Windows.UI.Xaml.Media.Animation {
  public sealed class ConnectedAnimation {
    bool IsScaleAnimationEnabled { get; set; }
    void SetAnimationComponent(ConnectedAnimationComponent component, ICompositionAnimationBase animation);
    bool TryStart(UIElement destination, IIterable<UIElement> coordinatedElements);
  }
  public enum ConnectedAnimationComponent
}
namespace Windows.UI.Xaml.Media.Imaging {
  public class SvgImageSource : ImageSource
  public sealed class SvgImageSourceFailedEventArgs
  public enum SvgImageSourceLoadStatus
  public sealed class SvgImageSourceOpenedEventArgs
}

namespace Windows.Media.Capture {
  public sealed class AppCaptureDurationGeneratedEventArgs
  public sealed class AppCaptureFileGeneratedEventArgs
  public enum AppCaptureMicrophoneCaptureState
  public sealed class AppCaptureMicrophoneCaptureStateChangedEventArgs
  public enum AppCaptureRecordingState
  public sealed class AppCaptureRecordingStateChangedEventArgs
  public sealed class AppCaptureRecordOperation
  public sealed class AppCaptureServices
  public sealed class AppCaptureSettings {
    bool IsCursorImageCaptureEnabled { get; set; }
    bool IsEchoCancellationEnabled { get; set; }
  }
  public sealed class AppCaptureState
}

namespace Windows.Security.EnterpriseData {
  public static class FileProtectionManager {
    public static IAsyncOperation<FileProtectionInfo> UnprotectAsync(IStorageItem target);
    public static IAsyncOperation<FileProtectionInfo> UnprotectAsync(IStorageItem target, FileUnprotectOptions options);
  }
  public sealed class FileUnprotectOptions
  public sealed class ProtectionPolicyManager {
    public static string PrimaryManagedIdentity { get; }
    public static string GetPrimaryManagedIdentityForIdentity(string identity);
    public static IAsyncOperation<bool> IsFileProtectionRequiredAsync(IStorageItem target, string identity);
    public static IAsyncOperation<bool> IsFileProtectionRequiredForNewFileAsync(IStorageFolder parentFolder, string identity, string desiredName);
    public static bool IsRoamableProtectionEnabled(string identity);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessAsync(string sourceIdentity, string targetIdentity, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessForAppAsync(string sourceIdentity, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForAppAsync(IIterable<IStorageItem> sourceItemList, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForAppAsync(IIterable<IStorageItem> sourceItemList, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForProcessAsync(IIterable<IStorageItem> sourceItemList, uint processId, ProtectionPolicyAuditInfo auditInfo);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForProcessAsync(IIterable<IStorageItem> sourceItemList, uint processId, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
  }
}

namespace Windows.Services.Store {
  public sealed class StoreContext {
    IAsyncOperation<StoreProductResult> FindStoreProductForPackageAsync(IIterable<string> productKinds, Package package);
  }
  public sealed class StoreSendRequestResult {
    HttpStatusCode HttpStatusCode { get; }
  }
}

namespace Windows.System.Profile {
  public static class SharedModeSettings {
    public static bool ShouldAvoidLocalStorage { get; }
  }
}

namespace Windows.Services.Cortana {
  public sealed class CortanaSettings
}
namespace Windows.System {
  public enum PowerState
  public static class ShutdownManager {
    public static void EnterPowerState(PowerState powerState);
    public static void EnterPowerState(PowerState powerState, TimeSpan wakeUpAfter);
    public static bool IsPowerStateSupported(PowerState powerState);
  }
}

API Removals

namespace Windows.UI.Composition {
  public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
  }
}
namespace Windows.UI.Composition.Interactions {
  public sealed class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
  }
}

Technorati Tags: , , , , ,