From humanitarian programs to new business tools: AI news from Microsoft’s Ignite conference – The AI Blog

At Microsoft’s Ignite conference in Orlando, Florida, this week, the company announced a number of new programs, tools and products aimed at showing how artificial intelligence can be used to help people in a variety of ways, whether that’s by helping humanitarian organizations or by providing tools to make machine learning more accessible.

The company announced the launch of a $40 million, five-year program called AI for Humanitarian Action. Microsoft said it will partner with non-governmental organizations and humanitarian groups to use AI to help with four key global challenges:

  • Disaster response: Support the ability to anticipate, predict and target humanitarian response efforts.
  • Needs of children: Ensure the safety and well-being of children.
  • Refugees and displaced people: Enable scalable collaboration in service of the approximate 68 million displaced people, including refugees.
  • Human rights: Accelerate breakthrough solutions to help monitor, detect and prevent human rights abuses.

The AI for Humanitarian Action program is the third program in Microsoft’s AI for Good initiative, a $115 million commitment launched last summer that also is working on ways to use AI for things like improving accessibility and environmental sustainability.

In addition to the AI for Humanitarian Action program, Microsoft unveiled a series of new and updated AI tools for developers and enterprise companies. Among the AI highlights announced at Ignite:

Cortana is getting an update that allows developers to enable the personal intelligent assistant to complete business-related tasks. The new Cortana Skills Kit for Enterprise, which is currently available by invitation only, will allow enterprises to use Cortana to do company-specific tasks. This development is the start of a journey into a world where voice and natural language are the primary means of interacting with technology, according to Javier Soltero, the Microsoft corporate vice president in charge of Cortana. “In the same way you don’t have to go around teaching people how to use a smartphone because they know how to touch and swipe, we have arrived there with voice, we are finally to, ‘Okay, now what can you do?’” he said.

Microsoft also announced new capabilities for its Azure Machine Learning service, a technology that allows anyone to build and train machine learning models to make predictions from data. These models can then be deployed anywhere – in the cloud, on premises or at the edge.  At the center of the update is automated machine learning, an AI capability that automatically selects, tests and tweaks machine learning models that power many of today’s AI systems. The capability is aimed at making AI development more accessible to a broader set of customers.

Azure Cognitive Services, a set of tools developers can use to add AI functionality such as image recognition into their own products, is making updates including the general availability of its speech service. The speech service combines several AI speech capabilities, including improved models for speech recognition, capabilities for speech translation and the ability to customize models to create a unique voice.

Microsoft also announced that it has reached a milestone in text-to-speech synthesis with a production system that uses deep neural networks to make the voices of computers nearly indistinguishable from recordings of people. That capability is currently available in preview.

This speech update plays off of the momentum of the recent launch of Video Indexer, which uses AI to scan audio and video files for things like especially emotional moments or high-level topics.

In addition, the Bot Framework SDK V4 is now available. The latest release makes human and computer interactions more natural. The previous version of the framework is used by more than 300,000 developers and it supports all major programming languages.

Of course, all these new AI tools and applications require real-time access to data. Microsoft announced a series of enhancements to its data offerings, including the preview of SQL Server 2019. “This is the best time to modernize your data and maximize the insights it can generate to transform your business,” says Rohan Kumar, corporate vice president, Azure Data. “Your data has so much potential.”

AI, cloud computing and IoT technology are already having a real-world impact on many big businesses. At Ignite, Shell and Microsoft showcased a pilot project that uses Azure IoT Edge, Azure IoT Hub and Azure Databricks to identify potential safety risks at Shell’s retail gas stations in the massive stream of data captured by closed-circuit video cameras — and quickly enough for employees to respond to potential problems. It’s just one of the ways that Shell and Microsoft are collaborating to help digitally transform a company that employs 85,000 people across 70 countries, manages critical energy infrastructure across the globe and operates 44,000 retail gas station and convenience store sites worldwide. “The new possibilities in working with data over the last few years are unlocking amazing opportunities in all aspects of what we do in the company,” said Yuri Sebregts, Shell’s executive vice president for technology and chief technology officer. “Most immediately, this will help us scale solutions we’ve been developing.”

Also at Ignite, Microsoft 365 introduced a series of updates that add more AI capabilities for everyone from individual workers to IT pros.

The new AI-powered tools in Microsoft 365 include:

  • Microsoft Search, a new unified search experience that lets employees find information and items across their organization’s entire network of data.
  • Background blur in Microsoft Teams, which uses facial detection to blur the background during video calls, so people can focus on the person and not what’s behind them, and an intelligent meeting recording function that automatically generates captions and a searchable, time-coded transcript.
  • Ideas, a new feature in Office that consolidates AI features into a simplified experience across Office 365, following the user along as she creates a document and making intelligent suggestions tailored to what she is doing.
  • Data Types in Excel, which turns references to things like stock prices, company information and population data into rich entities that can be used to build interactive spreadsheets. In addition, Insert Data from Picture is a new image recognition capability that lets users convert a picture of a data table into an Excel file that can be edited, analyzed and shared.

Shortly before Ignite, Microsoft also announced a new Dynamics 365 AI offering that includes AI-driven applications for sales, customer service and market insights.

Related:

CrowdStrike responds to NSS Labs lawsuit over product testing

The NSS Labs lawsuit against several major antimalware vendors marks the latest chapter in an ongoing feud between the testing firm and CrowdStrike, one of the most successful and visible cybersecurity vendors in the world.

NSS Labs, the independent cybersecurity testing company based in Austin, Texas, announced Wednesday that it had filed an antitrust suit against CrowdStrike, as well as Symantec, ESET and the Anti-Malware Testing Standards Organization (AMTSO) accusing the antimalware vendors and the AMTSO of conspiring to “restrict competition in the testing of cybersecurity products” by boycotting NSS Labs. The lawsuit further claims that vendors like CrowdStrike have used end-user license agreements that restrict comparative or competitive testing of their products by independent organizations like NSS Labs.

CrowdStrike initially declined to comment on the NSS Labs lawsuit because it was currently in litigation with the company and did not want to comment about an ongoing case. However, the cybersecurity vendor issued an updated statement Thursday that took NSS Labs to task.

“NSS is a for-profit, pay-to-play testing organization that obtains products through fraudulent means and is desperate to defend its business model from open and transparent testing,” CrowdStrike’s statement read. “We believe their lawsuit is baseless.”

Symantec, ESET and the AMTSO have not responded to requests for comment.

NSS Labs issued an additional statement to SearchSecurity Thursday indicating the antitrust suit could include additional parties in the future. “Those vendors (CrowdStrike, Symantec, ESET) and the vendor-driven AMTSO are named because they are the ones who are leading the conspiracy. There are other unnamed co-conspirators and their involvement will be determined during the course of this antitrust case.”

CrowdStrike and NSS Labs have been engaged in a high-profile legal dispute since 2017 when the vendor filed a lawsuit against the testing company regarding NSS Labs’ unflattering test results for CrowdStrike’s Falcon endpoint protection platform. The vendor sought a temporary restraining order and preliminary injunction against NSS Labs to prevent it from releasing a report for advanced endpoint protection product tests, which included a “caution” rating for CrowdStrike Falcon.

CrowdStrike accused NSS labs of faulty testing and argued that publishing the test results constituted a misappropriation of trade secrets and posed “irreparable harm” to the vendor. According to the lawsuit, the two parties struck a private agreement in April of 2016 to have NSS Labs test CrowdStrike Falcon and then provide a detailed report of the results to the vendor. But what happened after that is a disputed matter.

CrowdStrike claimed that NSS Labs “failed to perform the tests in a way that CrowdStrike deemed accurate and acceptable.” The lawsuit describes a second round of tests to address the issues that CrowdStrike identified, but during discussions of a third round of tests, NSS Labs informed the vendor that it planned a public test of the platform in early 2017. CrowdStrike objected to that test, which led the company to take legal action against NSS Labs to prevent the testing company from making the results public at RSA Conference 2017.

The day before RSA Conference began, a U.S. District Court judge denied CrowdStrike’s request for a temporary restraining order or preliminary injunction, and NSS Labs’ advanced endpoint protection report was published on Feb. 14.

In an accompanying blog post, CrowdStrike noted that NSS Labs admitted in its advanced endpoint protection report that the testing of CrowdStrike Falcon was “incomplete” and claimed that all “Falcon prevention capabilities” were incorrectly turned off during the tests.

“Including Falcon in the report based on an incomplete analysis is contrary to basic industry standards for testing,” CrowdStrike wrote.

NSS Labs, however, disputes that version of events. “We were unable to complete testing of the CrowdStrike Falcon Host product via a few attack vectors because CrowdStrike remotely disabled the product partway through our tests,” NSS Labs CEO Vikram Phatak wrote in a blog post

Phatak added that if NSS Labs had in fact disabled all Falcon prevention capabilities, then the platform would not have been able to stop any of the attacks the testers used, which was not the case.

The dispute over the advanced endpoint protection report marked a turning point, according to the NSS Labs lawsuit filed this week. Just as NSS Labs’ report was made public at RSA Conference 2017, the complaint alleges CrowdStrike organized a meeting of antimalware and endpoint protection vendors at the conference “with the express intent, purpose and effect of obtaining agreement among the competitors to refuse to do business with companies, including specifically NSS Labs” that used testing methodologies other than the AMTSO Testing Standard.

While NSS Labs is currently a member of AMTSO, the testing firm pushed back against the AMTSO Testing Standard, which NSS Labs argued gives vendors an unfair advantage. “Knowing how one’s product will be tested in advance defeats the entire purpose of independent third-party testing, no less than a student knowing the questions and answers before a test defeats the entire purpose of a school test,” the complaint reads. “Indeed, obtaining such knowledge is usually called ‘cheating.'”

AMTSO, meanwhile, issued a statement Friday responding to the NSS Labs lawsuit that categorically denies all claims made against the organization. In addition, AMTSO president Dennis Batchelder wrote a blog post contesting NSS Labs’ characterization of the organization and the testing standard.

“We were disappointed that one of our members chose to file an antitrust lawsuit against us and other AMTSO members. We were even more surprised at their allegation that our organization is only vendor-driven, which just isn’t true,” Batchelder wrote. “Our standard, as well as our guidelines and fundamental testing principles, were developed by both vendors and testers working together to ensure that our industry can provide customers with the best information possible.”

For Sale – Custom gaming PC (i7 7700k 4.2GHz, GTX 1070, 16gb RAM, 500gb SSD)

PCpartpicker link for full specs and the cost now to build new. I built this PC around July last year for £1500-£1600. It comes with all the original boxes, extras included with the components such as PSU cables, brackets etc, sleeved white extension cables and led strips with a remote. I was in my final year of university and rarely got to use it let alone game on it so everything is in impeccable condition, and I maintained it by dusting and staring at it lovingly when required.

Couple things to note: no OS and no WiFi card, but I can throw in a wireless adapter as well as a LAN cable. Pictures here but will post more detailed ones soon.

Price wise I want to be transparent and fair – is asking for 75% of the built new costs, £1100, reasonable? I am open to discussion. I’m not in a rush to get rid of it and didn’t get much use out of it, hence wanting a good price. Mostly selling to save up for my gap year.

I live in London and can deliver within London and the South if it’s not too far, and viewing and collecting are also options too. Can post my ebay account where I sold games/peripherals if you want to check reviews on me. Thank you for looking and please feel free to ask me questions.

Snapchat-1080648812.jpg

Price and currency: £1100
Delivery: Goods must be exchanged in person
Payment method: BT or PayPal
Location: London
Advertised elsewhere?: Not advertised elsewhere
Prefer goods collected?: I prefer the goods to be collected

______________________________________________________
This message is automatically inserted in all classifieds forum threads.
By replying to this thread you agree to abide by the trading rules detailed here.
Please be advised, all buyers and sellers should satisfy themselves that the other party is genuine by providing the following via private conversation to each other after negotiations are complete and prior to dispatching goods and making payment:

  • Landline telephone number. Make a call to check out the area code and number are correct, too
  • Name and address including postcode
  • Valid e-mail address

DO NOT proceed with a deal until you are completely satisfied with all details being correct. It’s in your best interest to check out these details yourself.

Windows 10 SDK Preview Build 17763 available now! – Windows Developer Blog

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17763 or greater). The Preview SDK Build 17763 contains bug fixes and under development changes to the API surface area.
The Preview SDK can be downloaded from developer section on Windows Insider.
For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 build 1803 or earlier to the store.
The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.
This build of the Windows SDK will install on Windows 10 Insider Preview builds and supported Windows operating systems.
In order to assist with script access to the SDK, the ISO will also be able to be accessed through the following URL: https://go.microsoft.com/fwlink/?prd=11966&pver=1.0&plcid=0x409&clcid=0x409&ar=Flight&sar=Sdsurl&o1=17763 once the static URL is published.

This update introduces many improvements and fixes for C++/WinRT. Notably, it introduces the ability to build C++/WinRT without any dependency on the Windows SDK. This isn’t particularly interesting to the OS developer, but even in the OS repo it provides benefits because it does not itself include any Windows headers. Thus, a developer will typically pull in fewer or no dependencies inadvertently. This also means a dramatic reduction in the number of macros that a C++/WinRT developer must guard against. Removing the dependency on the Windows headers means that C++/WinRT is more portable and standards compliant and furthers our efforts to make it a cross-compiler and cross-platform library. It also means that the C++/WinRT headers will never be mangled by macros. If you previously relied on C++/WinRT to include various Windows headers that you will now have to include them yourself. It has always been good practice to always include any headers you depend on explicitly and not rely on another library to include them for you.
Highlights
Support get_strong and get_weak to create delegates: This update allows a developer to use either get_strong or get_weak instead of a raw this pointer when creating a delegate pointing to a member function.
Add async cancellation callback: The most frequently requested feature for C++/WinRT’s coroutine support has been the addition of a cancellation callback.
Simplify the use of APIs expecting IBuffer parameters: Although most APIs prefer collections or arrays, enough APIs rely on IBuffer that it should be easier to use such APIs from C++. This update provides direct access to the data behind an IBuffer implementation using the same data naming convention used by the C++ standard library containers. This also avoids colliding with metadata names that conventionally begin with an uppercase letter.
Conformance: Improved support for Clang and Visual C++’s stricter conformance modes.
Improved code gen: Various improvements to reduce code size, improve inlining, and optimize factory caching.
Remove unnecessary recursion: When the command line refers to a folder rather than a specific winmd, cppwinrt will no longer search recursively for winmd files. It causes performance problems in the OS build and can lead to usage errors that are hard to diagnose when developers inadvertently cause cppwinrt to consume more winmds than expected. The cppwinrt compiler also now handles duplicates more intelligently, making it more resilient to user error and poorly-formed winmd files.
Declare both WINRT_CanUnloadNow and WINRT_GetActivationFactory in base.h: Callers don’t need to declare them directly. Their signatures have also changed, amounting to a breaking change. The declarations alleviate most of the pain of this change. The change is necessitated by the fact that C++/WinRT no longer depends on the Windows headers and this change removes the dependency on the types from the Windows headers.
Harden smart pointers: The event revokers didn’t revoke when move-assigned a new value. This lead me to take a closer look at the smart pointer classes and I noticed that they were not reliably handling self-assignment. This is rooted in the com_ptr class template that most of the others rely on. I fixed com_ptr and updated the event revokers to handle move semantics correctly to ensure that they revoke upon assignment. The handle class template has also been hardened by the removal of the implicit constructor that made it easy to write incorrect code. This also turned bugs in the OS into compiler errors fixed in this PR.
Breaking Changes
Support for non-WinRT interfaces is disabled by default. To enable, simply #include before any C++/WinRT headers.
winrt::get_abi(winrt::hstring) now returns void* instead of HSTRING. Code requiring the HSTRING ABI can simply use a static_cast.
winrt::put_abi(winrt::hstring) returns void** instead of HSTRING*. Code requiring the HSTRING ABI can simply use a reinterpret_cast.
HRESULT is now projected as winrt::hresult. Code requiring an HRESULT can simply static_cast if you need to do type checking or support type traits, but it is otherwise convertible as long as is included first.
GUID is now projected as winrt::guid. Code implementing APIs with GUID parameters must use winrt::guid instead, but it is otherwise convertible as long as is included first.
The signatures of WINRT_CanUnloadNow and WINRT_GetActivationFactory has changed. Code must not declare these functions at all and instead include winrt/base.h to include their declarations.
The winrt::handle constructor is now explicit. Code assigning a raw handle value must call the attach method instead.
winrt::clock::from_FILETIME has been deprecated. Code should use winrt::clock::from_file_time instead.

MSIX Support
It’s finally here! You can now package your applications as MSIX! These applications can be installed and run on any device with 17682 build or later.
To package your application with MSIX, use the MakeAppx tool. To install the application – just click on the MSIX file. To understand more about MSIX, watch this introductory video: link
Feedback and comments are welcome on our MSIX community: http://aka.ms/MSIXCommunity
MSIX is not currently supported by the App Certification Kit nor the Microsoft Store at this time.
MC.EXE
We’ve made some important changes to the C/C++ ETW code generation of mc.exe (Message Compiler):
The “-mof” parameter is deprecated. This parameter instructs MC.exe to generate ETW code that is compatible with Windows XP and earlier. Support for the “-mof” parameter will be removed in a future version of mc.exe.
As long as the “-mof” parameter is not used, the generated C/C++ header is now compatible with both kernel-mode and user-mode, regardless of whether “-km” or “-um” was specified on the command line. The header will use the _ETW_KM_ macro to automatically determine whether it is being compiled for kernel-mode or user-mode and will call the appropriate ETW APIs for each mode.

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

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

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

Known Issues:
The SDK headers are generated with types in the “ABI” namespace. This is done to avoid conflicts with C++/CX and C++/WinRT clients that need to consume types directly at the ABI layer[1]. By default, types emitted by MIDL are *not* put in the ABI namespace, however this has the potential to introduce conflicts from teams attempting to consume ABI types from Windows WinRT MIDL generated headers and non-Windows WinRT MIDL generated headers (this is especially challenging if the non-Windows header references Windows types).
To ensure that developers have a consistent view of the WinRT API surface, validation has been added to the generated headers to ensure that the ABI prefix is consistent between the Windows headers and user generated headers. If you encounter an error like:
5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): error C2220: warning treated as error – no ‘object’ file generated
5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): warning C4005: ‘CHECK_NS_PREFIX_STATE’: macro redefinition
5>g:(41): note: see previous definition of ‘CHECK_NS_PREFIX_STATE’
It means that some of your MIDL generated headers are inconsistent with the system generated headers.
There are two ways to fix this:

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

Windows App Certification Kit
When testing your app with the Windows App Certification Kit, the test may crash if your app includes 2 or more TargetDeviceFamily entries in the Package.appxmanifestfile. For example:

You can work around the issue by removing one of the TargetDeviceFamily entries.

When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts for more information.
The following APIs have been added to the platform since the release of 17134. The APIs below listed have been removed.
In addition, please note the following removal since build 17744:

namespace Windows.ApplicationModel.DataTransfer
{ public sealed class DataPackagePropertySetView : IIterable, IMapView {
string SourceDisplayName { get; } } }

Additions:

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

Removals:

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

The following APIs have been added to the Application Certification Kit list.

CM_Get_Device_Interface_List_SizeA
CM_Get_Device_Interface_List_SizeW
CM_Get_Device_Interface_ListA
CM_Get_Device_Interface_ListW
CM_MapCrToWin32Err
CM_Register_Notification
CM_Unregister_Notification
CoDecrementMTAUsage
CoIncrementMTAUsage
ColorAdapterGetCurrentProfileCalibration
ColorAdapterGetDisplayCurrentStateID
ColorAdapterGetDisplayProfile
ColorAdapterGetDisplayTargetWhitePoint
ColorAdapterGetDisplayTransformData
ColorAdapterGetSystemModifyWhitePointCaps
ColorAdapterRegisterOEMColorService
ColorAdapterUnregisterOEMColorService
ColorProfileAddDisplayAssociation
ColorProfileGetDisplayDefault
ColorProfileGetDisplayList
ColorProfileGetDisplayUserScope
ColorProfileRemoveDisplayAssociation
ColorProfileSetDisplayDefaultAssociation
DeviceIoControl
EventEnabled
EventProviderEnabled
ExitProcess
GetProductInfo
GetSystemTimes
InstallColorProfileA
InstallColorProfileW
LocalFileTimeToLocalSystemTime
LocalSystemTimeToLocalFileTime
MLCreateOperatorRegistry
RoIsApiContractMajorVersionPresent
RoIsApiContractPresent
RtlVirtualUnwind
SetProcessValidCallTargetsForMappedView
sqlite3_value_nochange
sqlite3_vtab_collation
sqlite3_vtab_nochange
sqlite3_win32_set_directory
sqlite3_win32_set_directory16
sqlite3_win32_set_directory8
ubiditransform_close
ubiditransform_open
ubiditransform_transform
ubrk_getBinaryRules
ubrk_openBinaryRules
unum_formatDoubleForFields
uplrules_getKeywords
uspoof_check2
uspoof_check2UTF8
uspoof_closeCheckResult
uspoof_getCheckResultChecks
uspoof_getCheckResultNumerics
uspoof_getCheckResultRestrictionLevel
uspoof_openCheckResult

Unlock limitless learning with Microsoft Education at Microsoft Ignite 2018 |

Ignite 2018.png

Microsoft Ignite is just around the corner, and we are so excited to have thousands of education tech professionals from around the globe join us to learn about the latest tools, technology and ideas from Microsoft.

At Ignite, we’ll share how Microsoft Education can help your institution achieve better learning outcomes for all your students, transform classroom time, and get all of this accomplished on affordable, easy to manage technology.  

Microsoft Education will have an interactive booth and 5 sessions where you can learn about the latest updates, connect with experts, and get your questions answered. Check out our curated guide below for education customers.

Not going to be at Ignite? No problem! All breakout sessions will be available to view via live stream and available 24-hours afterwards to view on-demand. Simply click on the breakout session link below to get viewing. If you want to explore more sessions at Ignite, log into  https://myignite.techcommunity.microsoft.com/ and find your sessions to add to your schedule to tune in live or on-demand.

BRK2403 – Demystifying Microsoft 365 Education

Tuesday September 25, 2-2:45pm

Microsoft 365 Education is designed to simplify IT with a single, secure solution that unlocks creativity and promotes teamwork in your school. Come learn how Microsoft 365 Education creates a path to transforming classroom time and modern IT management, and how the student use benefit can help you provide all your students with the very best in collaboration and productivity tools while keeping your entire organization protected and safe with intelligent security.

BRK2444 – Meeting the challenges of modern IT management for school

Wednesday September 26, 4:30-5:15pm

In order to meet the needs of teachers and students in the classroom, enable better teamwork with staff, and meet rigorous privacy and security standards, schools require solutions to be simple and impactful without overburdening IT or over extending on budget. In this session, learn how Microsoft cloud services makes it easy for a school to implement a full cloud solution. From managing user identity, automatically synced to the school’s Student Information System, to zero-touch device management that’s 84% faster to deploy than traditional methods and can provide a personalized experience to every student, even on shared devices.

BRK2296 – Microsoft Teams+OneNote+Forms+Flipgrid=Student achievement

Thursday September 27, 2-2:45pm

In this session, we share stories about schools and universities that are increasing student achievement by making learning more engaging, accessible, and fun. Join us as we demo a set of new and not-yet-released capabilities in Microsoft Teams, OneNote, Forms, and Flipgrid. We also show you other products that are designed to save educators time and to provide all students with opportunities to learn, collaborate, and develop their authentic voices.

BRK3126 – What’s New in EDU?: Updates to Microsoft Teams in Office 365 Education 

Thursday September 27th – 3:15pm-4:00pm

In the past year, teachers and students from around the world have used Microsoft Teams to engage student voice, streamline staff collaboration, and connect in new, fun, and meaningful ways. Learn about new experiences in Microsoft Teams for education, from teacher controls to updates to assignments. Also hear how education customers from throughout the world have leveraged Teams for collaborative learning and for streamlining staff communication.

BRK2443 – Transform classroom time with Microsoft Education

Friday September 28, 10:15-11am

Every moment a teacher spends away from connecting with and teaching their students is a moment lost. Learn how Microsoft Education helps unlock teachers from the busywork of managing day-to-day tasks and gives them more time and tools to teach, because when teachers have more time to teach and more tools to help engage with students, they don’t just do more things, they do amazing things.

Microsoft Education Booth

Catch us at the Microsoft Education booth (MW 313), where we’ll be showing a variety of education specific technology and devices.  We encourage you to stop by and share your questions and your feedback, which we count on in helping to make the best tools for education customers.

See you in Orlando!

– Microsoft Education team 

This post was originally published on this site.

Credit card giants step up AI fraud detection

SAN FRANCISCO — Youssef Lahrech, a senior vice president at Capital One, said his mother pays for things with a credit or debit card. She has one card, he said, but only uses it as a sort of last resort, to pay for items that can’t be bought with cash.

To him, this isn’t surprising. Years ago, a fraudster got to one of his mother’s accounts and wiped it out. She lost all her savings, and her financial security, in one instance.

It hit his family hard, which is one of the reasons why he said he has concentrated on bringing AI fraud detection tools to Capital One.

Fraud problems

“Fraud is a big business,” Lahrech said, speaking at The AI Summit. “Thirty billion dollars of fraud losses will happen this year,” and millions of Americans are yearly affected by fraud.

Successful fraudsters today take advantage of advanced technologies, using APIs and big data to help steal money, he said. But, as they have become more advanced, so have companies like Capital One.

The financial services giant uses a variety of behind-the-scenes machine learning (ML) and AI fraud detection tools to help identify potential fraud in milliseconds. The company’s system is designed “so that the customer will provide us with data by reporting,” Lahrech explained.

If a suspected fraudulent transaction is detected, a notification is sent to a customer’s phone instantly. The customer is then able to mark if the purchase was legitimate or not, and if not, the card is immediately locked down.

The system, by relying on input from millions of customers around the world, in a large-scale, general way, is able to better learn what type of transactions are more likely to be fraudulent.

AI Summit, Youssef Lahrech, Capital One
Youssef Lahrech of Capital One at The AI Summit in San Francisco

Taking on fraud with bots

The system, however, is scalable, and is able to learn in more personalized ways, as well, Lahrech said. Recently, the company rolled out Eno, a chatbot-type of virtual assistant that can do things like break down a customer’s charges or alert a customer to fraud through a conversational user interface.

ML is changing the world, one service at a time.
Youssef Lahrechsenior vice president at Capital One

The AI fraud detection tool uses natural language processing (NLP) to accept a wide range of interactive responses from customers if it does report fraud, which Lahrech said can help Capital One build more of a context around the potential fraud case. An example is with cases of “friendly fraud,” or when a consumer tried to defraud a credit card company, in which the issues can be complex.

With ML technology, those answers from customers can be used to give more personalized responses, and also establish a profile based on pattern recognition.

Such a profile, which could include information on how a customer usually writes or fills out a form, “lets us create a better layer of protection,” Lahrech noted, and could ultimately be used to find out if a scammer or a bot is impersonating them.

These ML and AI fraud detection tools have largely been successful at Capital One by significantly boosting the company’s ability to automatically and accurately flag fraudulent activity, Lahrech said.

“ML is changing the world, one service at a time,” he said. “Your banking will go from something you pull out of your pocket when you need to do it to a virtual personal assistant.”

Personalized profile

Meanwhile, Rahul Deshpande, senior vice president of digital strategy integration at Mastercard, in a separate talk at The AI Summit spoke about some of the AI fraud detection tools in place at Mastercard.

Like at Capital One, ML technologies at Mastercard have enabled the company to create more advanced ways to flag fraudulent behavior. The credit card company does this by creating pattern-based profiles for consumers, which Deshpande said can help with identifying a real user versus an advanced bot trying to imitate that user.

Relying on data gleaned from ML and AI fraud detection tools is important, he said, because after so many hacks of so many different companies, and with so much personal data in the hands of criminals, “traditional data sources that we have are probably not good, are compromised.”

AI Summit, Rahul Deshpande, Mastercard
Rahul Deshpande of Mastercard at The AI Summit in San Francisco

The AI Summit, held Sept. 19 to 20, drew hundreds of companies that use ML and AI.

For Sale – Gaming pc with 1080 plus acer 34xa monitor

Hi guys I am selling my pcspecialist gaming pc as well as my Acer predator x34a monitor.

The specs for the pc :

Case FRACTAL DEFINE S BLACK GAMING CASE (Window)
Overclocked CPU Overclocked Intel® Core™i7-6700k Quad Core (4.00GHz @ upto MAX 4.60GHz)
Motherboard ASUS® Z170 PRO GAMING: ATX, LG1151, USB 3.1, SATA 6GBs
Memory (RAM) 16GB HyperX SAVAGE DDR4 3000MHz (2 x 8GB Kit)
Graphics Card 8GB NVIDIA GEFORCE GTX 1080 – DVI, HDMI, 3x DP – GTX VR Ready!
1st Hard Disk 2TB SATA-III 3.5″ HDD, 6GB/s, 7200RPM, 64MB CACHE
M.2 SSD Drive 256GB SAMSUNG PM951 M.2, PCIe NVMe (up to 1000MB/R, 280MB/W)
Power Supply CORSAIR 650W CS SERIES™ MODULAR 80 PLUS® GOLD, ULTRA QUIET
Processor Cooling Noctua NH-D15S Ultra Quiet Performance CPU Cooler
Thermal Paste ARCTIC MX-4 EXTREME THERMAL CONDUCTIVITY COMPOUND
LED Lighting 2x 60cm Green LED Strip – To Compliment The Colours of Your Case
Sound Card ONBOARD 6 CHANNEL (5.1) HIGH DEF AUDIO (AS STANDARD)
Wireless/Wired Networking 10/100/1000 GIGABIT LAN PORT (Wi-Fi NOT INCLUDED)
USB Options MIN. 2 x USB 3.0 & 2 x USB 2.0 PORTS @ BACK PANEL + MIN. 2 FRONT
PORTS

Plus the acer x34a 34″ monitor, this monitor overclocks to 100hz no problem, I went through 3 monitors before I settled on this one as it exhibits the least lcd bloom and backlight bleed, I am very particular about these things.

The pc and monitor are in excellent condition, with no marks or dents, and have served me very well. I have installed a couple of extra fans in the case to keep it cool, the system has not been excessively overlooked, and can be seen to work flawlessly.

As part of the setup I am also using a wireless top of the range logitech g903 gaming mice and a ducky shine 4 red switch gaming keyboard. I have a creative soundblaster e5 dac/amp to drive my Bayer dynamic DT990 Pro limited edition headphones, these items can be bought for a good price as well part of the system.

The pc has one year left of warranty with pcspecialist, that I am willing to honour.

I am selling as I am not spending enough time on the system to warrant such a premium setup, thought that I might as well cash in on it now whilst it’s still worth something.

Please don’t hesitate to ask questions.

Thank you

Price and currency: 1400
Delivery: Goods must be exchanged in person
Payment method: Cash, bank transfer or PayPal
Location: Cardiff
Advertised elsewhere?: Not advertised elsewhere
Prefer goods collected?: I prefer the goods to be collected

______________________________________________________
This message is automatically inserted in all classifieds forum threads.
By replying to this thread you agree to abide by the trading rules detailed here.
Please be advised, all buyers and sellers should satisfy themselves that the other party is genuine by providing the following via private conversation to each other after negotiations are complete and prior to dispatching goods and making payment:

  • Landline telephone number. Make a call to check out the area code and number are correct, too
  • Name and address including postcode
  • Valid e-mail address

DO NOT proceed with a deal until you are completely satisfied with all details being correct. It’s in your best interest to check out these details yourself.

Latest News from Microsoft Ignite 2018 – Updates, Interviews & More

It’s that time of year again, where IT Pros, developers and system administrators descend on Orlando, Florida to hear about the latest and greatest tech being introduced in the Microsoft Stack. When one thinks of a tech conference they likely are stuck with the thought of a bunch of reserved geeky individuals sitting quietly in chairs while they all frantically type away at their laptops. This could not be further from the truth. The truth is, this place is absolutely brimming with energy! Microsoft has actively transformed itself from being the stuffy business computing vendor of choice to an operating-on-the-bleeding-edge-of-innovation tech giant with the swagger of the likes of Apple. When you attend Ignite, you really feel like the tech world is changing, and that is quite evident when you stand back and process the full breadth of Microsoft’s announcements and see where things are headed.

While I’ll be crafting a future blog post that somewhat analyzes Microsoft’s vision further, this post will serve to be factual, in that, what are the new things on their way to market in the Microsoft space? Let’s take a look.

The Mission

The mission statement hasn’t changed, but it’s as powerful as ever. Each new announcement server to enable individuals and organizations around the world to achieve more.

Discussing the Microsoft Ignite 2018 Keynote

With so many announcements and improvements, it can be difficult to parse through it all. With that in mind, I sat down with two MVP buddies of mine and we talked about our thoughts and reactions to the announcements made during the keynote. Check it out below.

[embedded content]

The Announcements

Let’s start with the biggest and likely the most impactful announcement for IT pros.

Windows Server 2019 General Availability in October

Get those upgrade plans ready, because as of next month Windows Server 2019 is out of technical preview. If you’ve been following our blog over the last half year, you’ve likely known that this was coming soon but with it being out of the testing phase, you can really start to put some of the great new features into production. There is a TON of tech goodness contained in this release.

  • Storage Enhancements for Storage Spaces Direct
  • A TON of virtualization relevant Networking enhancements such as LEDBAT
  • System Insights
  • Increased Support for Containers on Windows
  • And a BUNCH more

Windows Server 2019 is really going to be the gap filler for that space between on-prem and the cloud.

Read what the wider IT community is saying about Windows Server 2019

We will be having an in-depth discussion about the new features in Windows Server 2019 next week on October 3rd at our webinar What’s New in Windows Server 2019. Save your seat now

Windows Server 2019 free webinar from Altaro

Open Data Initiative

With the proliferation of the cloud, access and control of data has (rightly so) become a huge concern for companies starting to leverage cloud technologies. To address this concern Microsoft, SAP, and Adobe have made a joint announcement that they have all created the Open Data Initiative. The whole idea here is to ensure that services from these three platforms all play nicely and are certified to work together in a reliable fashion. All the while giving the end customer, full control and full transparency in how the data is used, stored and accessed.

Azure Sphere

One thing that became VERY apparent over the course of the first day is that Microsoft is going all out for IoT. They see IoT as not only the next exploding area of IT but also the next battleground for cyber-attacks. Satya Nadella said right in his keynote that they don’t see the next major attacks happening on a “traditional computer” but on an IoT edge device, such as an HVAC system controller, or something of that nature. Azure Sphere is a new service that will help IT Pros wrap their hands around IoT devices and secure them for the next generation of IT workloads

AI for Humanitarian Action

While less of a product and more of an initiative at this point, I was really touched and inspired by the human aspect of this announcement. Microsoft really focused in on the ways that AI can be used to better mankind, and that is even more so needed during a humanitarian crisis. Microsoft will be leading a push to enable the power of AI to help solve these problems and ultimately make the world a better place. A truly inspiring initiative.

SQL Server 2019

While we’re not a data-focused blog, SQL Server 2019 is a big deal for many organizations. With that said, it’s continued to be updated and modernized for cloud use and has seen considerable enhancements and improvements in scalability. It’s also worth noting that there are some really interesting use cases here for hybrid scenarios and design options for running SQL 2019 in conjunction with Azure.

A Massive Number of Azure Enhancements

Azure has quickly become Microsoft’s Bread and Butter, and with it comes vast amounts of attention from Microsoft and the community as well. As such, there has been no lack of Azure focused announcements this week, and at this point it’s too many to count. There are far too many to cover in a single post, but some of the highlights include:

  • New VM Sizes focused on various workloads including Nvidia graphical workloads
  • UltraSSD Storage with up to 160000 (yes…. 4 zeros) IOPS
  • Azure Virtual WAN and other networking enhancements
  • Azure Front Door Service
  • Azure Data Box GA and additional SKUs
  • Red Hat OpenShift is coming to an Azure Datacenter near you
  • Azure Blueprints for rolling out entire subscriptions in an automated fashion
  • And more!

We’ll be cover many of these in greater detail in the coming weeks and months, but as you can see, Microsoft has been hard at work in the Azure Space!

Windows Virtual Desktop

This is a feature that I’m surprised has taken this long to get to market. Windows Virtual Desktop is a new service that will allow you to connect end users to Windows 10 Desktops running in Azure from a multitude of devices. It’s basically RDS running in Azure. I know many IT Pros and MSPs that have been looking forward to this for a long time, and instead of having to focus on hosting that infrastructure themselves, Azure can help them do it in a pay-as-you-go consumable manner. It’ll be fun to see how this one evolves over time.

More to Come!

Don’t think for a second that this is the end! We have MUCH more Ignite-focused content coming your way throughout the week and in the near future as well. With that said, what new piece of technology are you looking to get your hands on? What would you like us to cover more on our blog? Let us know in the comments section below!

Thanks for reading!

Microsoft Mission Statement

Microsoft Ignite and Microsoft Envision 2018

Creating a more secure, intelligent and connected enterprise at Ignite 2018

Ignite is all about our customers—of course they attend, but we also give the mic to customers to participate in Satya’s and other executives’ keynotes, as well as sessions and workshops. Literally hundreds of sessions at Ignite are led by customers, such as Buhler, Shell, H&M and others.

Read more…

Cisco Webex Edge connects data centers to the cloud

Cisco unveiled a set of hybrid cloud services that will help companies with on-premises calling and video infrastructure take advantage of the Webex collaboration cloud. Cisco Webex Edge will reduce PSTN costs and improve audio and video connectivity for those customers, the vendor said.

Webex Edge Audio lets companies with Cisco Unified Communications Manager conduct Webex audio conferencing using a voice over IP (VoIP) connection, rather than the public switched telephone network (PSTN).

Users joining Webex meetings on a laptop can already use VoIP for audio connectivity. But connecting using a mobile, home or desk phone typically requires the use of the PSTN. Companies usually pay by the minute for PSTN dial-in and dial-out services.

Webex Edge Audio lets companies use their on-premises call servers to establish VoIP connections to the Webex cloud. That way, companies can avoid paying PSTN fees when employees connect to Webex audio using Cisco desk phones.

“It allows you to much more efficiently use your network resources, reduce the amount of calls you’re taking in through the PSTN and, ideally, hopefully, save some money,” said Irwin Lazar, analyst at Nemertes Research, based in Mokena, Ill.

Zoom offers a similar feature that lets large customers establish a Session Initiation Protocol connection to the Zoom cloud to avoid PSTN costs. Last month, the vendor expanded the service to give customers more flexibility over which calls get directed to which audio port.

Cisco plays catch-up with Edge Connect

The second feature of Cisco Webex Edge lets companies establish IP connections between their data centers and the Cisco collaboration cloud via Equinix Cloud Exchange. The feature, Edge Connect, will help companies avoid congestion, packet loss and jitter while using Webex, the vendor said.

Cisco’s lack of support for such connections had concerned many prospective customers, Lazar said. Leading cloud infrastructure vendors, including Amazon Web Services, Microsoft Azure and Google Cloud, have offered similar services for some time.

“Cisco is kind of late a little bit to the party to have this kind of offering,” he said.

In a 2017 Nemertes Research survey of 50 large enterprises in North America, 35.7% of respondents reported using a service similar to Cisco Webex Edge Connect to link their network to their unified-communications-as-a-service provider.

Cisco seeks advantage with Video Mesh

The third and final feature of Cisco Webex Edge is Video Mesh, a service Cisco previously released under the name Hybrid Media Services. The setup lets companies conduct video conferencing through a combination of on-premises servers and the cloud.

The service could, for example, automatically direct video connections originating in a company headquarters to the on-premises servers, while connecting remote workers to the meeting via the cloud. Alternatively, it could start a session in the data center and overflow to the cloud if too many people join.

In a global Nemertes Research survey of 500 businesses this year, 41.7% of respondents said being able to conduct video conferencing on their networks was a “very important” or “vital” feature when evaluating cloud web conferencing platforms.

Cisco’s Video Mesh appears to be the most advanced offering of its kind in the web conferencing market, Lazar said.

“[Cisco] is heavily focused on Zoom and Microsoft, and they are trying to figure out, ‘How do we differentiate?’ Having that on-prem video routing engine that allows companies to more efficiently use bandwidth is an area they can get out ahead with,” Lazar said.