30 Mar 2018

Windows 10 SDK Preview Build 17125

Author: Clint Rutkas
Go to Source

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

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

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

Things to note:

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

What’s New:

  • C++/WinRT Now Available: The C++/WinRT headers and cppwinrt compiler (cppwinrt.exe) are now included in the Windows SDK. The compiler comes in handy if you need to consume a third-party WinRT component or if you need to author your own WinRT components with C++/WinRT. The easiest way to get working with it after installing the Windows Insider Preview SDK is to start the Visual Studio Developer Command Prompt and run the compiler in that environment. Authoring support is currently experimental and subject to change. Stay tuned as we will publish more detailed instructions on how to use the compiler in the coming week.The ModernCPP blog has a deeper dive into the CppWinRT compiler.

Breaking ChangesAPI Updates and Additions

  • New MIDL key words.

As a part of the “modernizing IDL” effort, several new keywords are added to the midlrt tool. These new keywords will cause build breaks if they are encountered in IDL files.

The new keywords are:

  • event
  • set
  • get
  • partial
  • unsealed
  • overridable
  • protected
  • importwinmd

If any of these keywords is used as an identifier, it will generate a build failure indicating a syntax error.

The error will be similar to:

1 >d:ossrconecorecomcombaseunittestastatestserverstestserver6idlremreleasetest.idl(12) : error MIDL2025 : [msg]syntax error [context]: expecting a declarator or * near “)”

To fix this, modify the identifier in error to an “@” prefix in front of the identifier. That will cause MIDL to treat the offending element as an identifier instead of a keyword.

API Updates and Additions

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

The following APIs have been added to the platform since the release of 16299.


namespace Windows.AI.MachineLearning.Preview {
  public enum FeatureElementKindPreview
  public interface ILearningModelVariableDescriptorPreview
  public sealed class ImageVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public sealed class InferencingOptionsPreview
  public sealed class LearningModelBindingPreview : IIterable<IKeyValuePair<string, object>>, IMapView<string, object>
  public sealed class LearningModelDescriptionPreview
  public enum LearningModelDeviceKindPreview
  public sealed class LearningModelEvaluationResultPreview
  public enum LearningModelFeatureKindPreview
  public sealed class LearningModelPreview
  public sealed class LearningModelVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public struct MachineLearningPreviewContract
  public sealed class MapVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public sealed class SequenceVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
  public sealed class TensorVariableDescriptorPreview : ILearningModelVariableDescriptorPreview
}
namespace Windows.ApplicationModel {
  public enum AddResourcePackageOptions : uint
  public sealed class AppInstance
  public sealed class PackageCatalog {
    IAsyncOperationWithProgress<PackageCatalogAddResourcePackageResult, PackageInstallProgress> AddResourcePackageAsync(string resourcePackageFamilyName, string resourceID, AddResourcePackageOptions options);
    IAsyncOperation<PackageCatalogRemoveResourcePackagesResult> RemoveResourcePackagesAsync(IIterable<Package> resourcePackages);
  }
  public sealed class PackageCatalogAddResourcePackageResult
  public sealed class PackageCatalogRemoveResourcePackagesResult
  public struct PackageInstallProgress
  public enum StartupTaskState {
    EnabledByPolicy = 4,
  }
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    BarcodeScannerProvider = 1022,
  }
  public sealed class BarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public interface IBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs
}
namespace Windows.ApplicationModel.Background {
  public enum BackgroundAccessRequestKind
  public static class BackgroundExecutionManager {
    public static IAsyncOperation<bool> RequestAccessKindAsync(BackgroundAccessRequestKind requestedAccess, string reason);
  }
  public sealed class CustomSystemEventTrigger : IBackgroundTrigger
  public enum CustomSystemEventTriggerRecurrence
  public sealed class MobileBroadbandPcoDataChangeTrigger : IBackgroundTrigger
  public sealed class NetworkOperatorDataUsageTrigger : IBackgroundTrigger
  public sealed class StorageLibraryChangeTrackerTrigger : IBackgroundTrigger
  public sealed class TetheringEntitlementCheckTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
  public enum PhoneCallMedia {
    AudioAndRealTimeText = 2,
  }
  public sealed class VoipCallCoordinator {
    VoipPhoneCall RequestNewAppInitiatedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
    VoipPhoneCall RequestNewIncomingCall(string context, string contactName, string contactNumber, Uri contactImage, string serviceName, Uri brandingImage, string callDetails, Uri ringtone, VoipPhoneCallMedia media, TimeSpan ringTimeout, string contactRemoteId);
  }
  public sealed class VoipPhoneCall {
    void NotifyCallAccepted(VoipPhoneCallMedia media);
  }
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    IAsyncOperation<bool> LaunchForUserAsync(User user);
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackagePropertySet : IIterable<IKeyValuePair<string, object>>, IMap<string, object> {
    string ContentSourceUserActivityJson { get; set; }
  }
  public sealed class DataPackagePropertySetView : IIterable<IKeyValuePair<string, object>>, IMapView<string, object> {
    string ContentSourceUserActivityJson { get; }
  }
  public static class StandardDataFormats {
    public static string UserActivityJsonArray { get; }
  }
}
namespace Windows.ApplicationModel.Store.Preview {
  public enum StoreSystemFeature {
    ArchitectureArm64 = 34,
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallItem {
    bool LaunchAfterInstall { get; set; }
  }
  public sealed class AppInstallManager {
    IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallAsync(string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallForUserAsync(User user, string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesAsync(string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync(User user, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesAsync(string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync(User user, string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync(string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync(User user, string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
  }
  public sealed class AppInstallOptions
  public sealed class AppInstallStatus {
    bool IsStaged { get; }
  }
  public sealed class AppUpdateOptions
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity {
    public UserActivity(string activityId);
    string ToJson();
    public static string ToJsonArray(IIterable<UserActivity> activities);
    public static UserActivity TryParseFromJson(string json);
    public static IVector<UserActivity> TryParseFromJsonArray(string json);
  }
  public sealed class UserActivityChannel {
    public static void DisableAutoSessionCreation();
    IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetRecentUserActivitiesAsync(int maxUniqueActivities);
    IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetSessionHistoryItemsForUserActivityAsync(string activityId, DateTime startTime);
    public static UserActivityChannel TryGetForWebAccount(WebAccount account);
  }
  public sealed class UserActivityRequest
  public sealed class UserActivityRequestedEventArgs
  public sealed class UserActivityRequestManager
  public sealed class UserActivitySessionHistoryItem
  public sealed class UserActivityVisualElements {
    string AttributionDisplayText { get; set; }
  }
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter {
    bool AreClassicSecureConnectionsSupported { get; }
    bool AreLowEnergySecureConnectionsSupported { get; }
  }
  public sealed class BluetoothDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
  public sealed class BluetoothLEDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
}
namespace Windows.Devices.Display {
  public sealed class DisplayMonitor
  public enum DisplayMonitorConnectionKind
  public enum DisplayMonitorDescriptorKind
  public enum DisplayMonitorPhysicalConnectorKind
  public enum DisplayMonitorUsageKind
}
namespace Windows.Devices.Input.Preview {
  public enum GazeDeviceConfigurationStatePreview
  public sealed class GazeDevicePreview
  public sealed class GazeDeviceWatcherAddedPreviewEventArgs
  public sealed class GazeDeviceWatcherPreview
  public sealed class GazeDeviceWatcherRemovedPreviewEventArgs
  public sealed class GazeDeviceWatcherUpdatedPreviewEventArgs
  public sealed class GazeEnteredPreviewEventArgs
  public sealed class GazeExitedPreviewEventArgs
  public sealed class GazeInputSourcePreview
  public sealed class GazeMovedPreviewEventArgs
  public sealed class GazePointPreview
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScannerReport {
    public BarcodeScannerReport(uint scanDataType, IBuffer scanData, IBuffer scanDataLabel);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    bool IsVideoPreviewShownOnEnable { get; set; }
    void HideVideoPreview();
    IAsyncOperation<bool> ShowVideoPreviewAsync();
  }
  public sealed class UnifiedPosErrorData {
    public UnifiedPosErrorData(string message, UnifiedPosErrorSeverity severity, UnifiedPosErrorReason reason, uint extendedReason);
  }
}
namespace Windows.Devices.PointOfService.Provider {
  public sealed class BarcodeScannerDisableScannerRequest
  public sealed class BarcodeScannerDisableScannerRequestEventArgs
  public sealed class BarcodeScannerEnableScannerRequest
  public sealed class BarcodeScannerEnableScannerRequestEventArgs
  public sealed class BarcodeScannerGetSymbologyAttributesRequest
  public sealed class BarcodeScannerGetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerHideVideoPreviewRequest
  public sealed class BarcodeScannerHideVideoPreviewRequestEventArgs
  public sealed class BarcodeScannerProviderConnection : IClosable
  public sealed class BarcodeScannerProviderTriggerDetails
  public sealed class BarcodeScannerSetActiveSymbologiesRequest
  public sealed class BarcodeScannerSetActiveSymbologiesRequestEventArgs
  public sealed class BarcodeScannerSetSymbologyAttributesRequest
  public sealed class BarcodeScannerSetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerStartSoftwareTriggerRequest
  public sealed class BarcodeScannerStartSoftwareTriggerRequestEventArgs
  public sealed class BarcodeScannerStopSoftwareTriggerRequest
  public sealed class BarcodeScannerStopSoftwareTriggerRequestEventArgs
  public enum BarcodeScannerTriggerState
  public sealed class BarcodeSymbologyAttributesBuilder
}
namespace Windows.Foundation.Numerics {
  public struct Rational
}
namespace Windows.Globalization {
  public static class ApplicationLanguages {
    public static IVectorView<string> GetLanguagesForUser(User user);
  }
  public sealed class Language {
    LanguageLayoutDirection LayoutDirection { get; }
  }
  public enum LanguageLayoutDirection
}
namespace Windows.Graphics {
  public struct DisplayAdapterId
  public interface IGeometrySource2D
}
namespace Windows.Graphics.Capture {
  public sealed class Direct3D11CaptureFrame : IClosable
  public sealed class Direct3D11CaptureFramePool : IClosable
  public sealed class GraphicsCaptureItem
  public sealed class GraphicsCapturePicker
  public sealed class GraphicsCaptureSession : IClosable
}
namespace Windows.Graphics.DirectX {
  public enum DirectXColorSpace
}
namespace Windows.Graphics.Display {
  public sealed class AdvancedColorInfo
  public enum AdvancedColorKind
  public sealed class BrightnessOverrideSettings
  public sealed class ColorOverrideSettings
  public enum DisplayBrightnessOverrideScenario
  public enum DisplayColorOverrideScenario
  public sealed class DisplayEnhancementOverride
  public sealed class DisplayEnhancementOverrideCapabilities
  public sealed class DisplayEnhancementOverrideCapabilitiesChangedEventArgs
  public sealed class DisplayInformation {
    event TypedEventHandler<DisplayInformation, object> AdvancedColorInfoChanged;
    AdvancedColorInfo GetAdvancedColorInfo();
  }
  public enum HdrMetadataFormat
  public struct NitRange
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool CanOverrideViewport { get; }
  }
  public sealed class HolographicCameraPose {
    void OverrideProjectionTransform(HolographicStereoTransform projectionTransform);
    void OverrideViewport(Rect leftViewport, Rect rightViewport);
    void OverrideViewTransform(SpatialCoordinateSystem coordinateSystem, HolographicStereoTransform coordinateSystemToViewTransform);
  }
  public sealed class HolographicFramePresentationMonitor : IClosable
  public sealed class HolographicFramePresentationReport
  public sealed class HolographicSpace {
    HolographicSpaceUserPresence UserPresence { get; }
    event TypedEventHandler<HolographicSpace, object> UserPresenceChanged;
    HolographicFramePresentationMonitor CreateFramePresentationMonitor(uint maxQueuedReports);
    void WaitForNextFrameReady();
    void WaitForNextFrameReadyWithHeadStart(TimeSpan requestedHeadStartDuration);
  }
  public enum HolographicSpaceUserPresence
}
namespace Windows.Graphics.Imaging {
  public enum BitmapPixelFormat {
    P010 = 104,
  }
}
namespace Windows.Graphics.Printing {
  public sealed class PrintPageRange
  public sealed class PrintPageRangeOptions
  public sealed class PrintTaskOptions : IPrintTaskOptionsCore, IPrintTaskOptionsCoreProperties, IPrintTaskOptionsCoreUIConfiguration {
    IVector<PrintPageRange> CustomPageRanges { get; }
    PrintPageRangeOptions PageRangeOptions { get; }
  }
  public static class StandardPrintTaskOptions {
    public static string CustomPageRanges { get; }
  }
}
namespace Windows.Graphics.Printing.OptionDetails {
  public sealed class PrintBindingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintBorderingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCollationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintColorModeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCopiesOptionDetails : IPrintNumberOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomItemListOptionDetails : IPrintCustomOptionDetails, IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
    void AddItem(string itemId, string displayName, string description, IRandomAccessStreamWithContentType icon);
  }
  public sealed class PrintCustomTextOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomToggleOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails
  public sealed class PrintDuplexOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintHolePunchOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintMediaSizeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintMediaTypeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public enum PrintOptionType {
    Toggle = 4,
  }
  public sealed class PrintOrientationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintPageRangeOptionDetails : IPrintOptionDetails
  public sealed class PrintQualityOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintStapleOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintTaskOptionDetails : IPrintTaskOptionsCore, IPrintTaskOptionsCoreUIConfiguration {
    PrintCustomToggleOptionDetails CreateToggleOption(string optionId, string displayName);
  }
}
namespace Windows.Management.Deployment {
  public sealed class PackageManager {
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris, IIterable<Uri> packageUrisToInstall);
  }
}
namespace Windows.Management.Update {
  public sealed class PreviewBuildsManager
  public sealed class PreviewBuildsState
}
namespace Windows.Media {
  public sealed class VideoFrame : IClosable, IMediaFrame {
    IAsyncAction CopyToAsync(VideoFrame frame, IReference<BitmapBounds> sourceBounds, IReference<BitmapBounds> destinationBounds);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height, IDirect3DDevice device);
    public static VideoFrame CreateWithDirect3D11Surface(IDirect3DSurface surface);
    public static VideoFrame CreateWithSoftwareBitmap(SoftwareBitmap bitmap);
  }
}
namespace Windows.Media.Audio {
  public sealed class AudioGraph : IClosable {
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource);
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource, AudioNodeEmitter emitter);
  }
  public sealed class AudioGraphSettings {
    double MaxPlaybackSpeedFactor { get; set; }
  }
  public sealed class AudioStateMonitor
  public sealed class CreateMediaSourceAudioInputNodeResult
  public sealed class MediaSourceAudioInputNode : IAudioInputNode, IAudioInputNode2, IAudioNode, IClosable
  public enum MediaSourceAudioInputNodeCreationStatus
}
namespace Windows.Media.Capture {
  public sealed class CapturedFrame : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType {
    BitmapPropertySet BitmapProperties { get; }
    CapturedFrameControlValues ControlValues { get; }
  }
  public enum KnownVideoProfile {
    HdrWithWcgPhoto = 8,
    HdrWithWcgVideo = 7,
    HighFrameRate = 5,
    VariablePhotoSequence = 6,
    VideoHdr8 = 9,
  }
  public sealed class MediaCaptureSettings {
    IDirect3DDevice Direct3D11Device { get; }
  }
  public sealed class MediaCaptureVideoProfile {
    IVectorView<MediaFrameSourceInfo> FrameSourceInfos { get; }
    IMapView<Guid, object> Properties { get; }
  }
  public sealed class MediaCaptureVideoProfileMediaDescription {
    IMapView<Guid, object> Properties { get; }
    string Subtype { get; }
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class AudioMediaFrame
  public sealed class MediaFrameFormat {
    AudioEncodingProperties AudioEncodingProperties { get; }
  }
  public sealed class MediaFrameReference : IClosable {
    AudioMediaFrame AudioMediaFrame { get; }
  }
  public sealed class MediaFrameSourceController {
    AudioDeviceController AudioDeviceController { get; }
  }
  public sealed class MediaFrameSourceInfo {
    string ProfileId { get; }
    IVectorView<MediaCaptureVideoProfileMediaDescription> VideoProfileMediaDescription { get; }
  }
  public enum MediaFrameSourceKind {
    Audio = 4,
    Image = 5,
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    AudioStreamDescriptor Copy();
  }
  public sealed class MediaBindingEventArgs {
    void SetDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    DownloadOperation DownloadOperation { get; }
    public static MediaSource CreateFromDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class TimedMetadataStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    VideoStreamDescriptor Copy();
  }
}
namespace Windows.Media.Devices {
  public sealed class VideoDeviceController : IMediaDeviceController {
    VideoTemporalDenoisingControl VideoTemporalDenoisingControl { get; }
  }
  public sealed class VideoTemporalDenoisingControl
  public enum VideoTemporalDenoisingMode
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp {
    IAsyncOperation<string> GetUniqueDeviceNameAsync();
  }
}
namespace Windows.Media.Effects {
  public sealed class VideoTransformEffectDefinition : IVideoEffectDefinition {
    VideoTransformSphericalProjection SphericalProjection { get; }
  }
  public sealed class VideoTransformSphericalProjection
}
namespace Windows.Media.MediaProperties {
  public sealed class AudioEncodingProperties : IMediaEncodingProperties {
    AudioEncodingProperties Copy();
  }
  public sealed class ContainerEncodingProperties : IMediaEncodingProperties {
    ContainerEncodingProperties Copy();
  }
  public sealed class ImageEncodingProperties : IMediaEncodingProperties {
    ImageEncodingProperties Copy();
  }
  public sealed class MediaEncodingProfile {
    IVector<TimedMetadataStreamDescriptor> GetTimedMetadataTracks();
    void SetTimedMetadataTracks(IIterable<TimedMetadataStreamDescriptor> value);
  }
  public static class MediaEncodingSubtypes {
    public static string P010 { get; }
  }
  public enum MediaPixelFormat {
    P010 = 2,
  }
  public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    VideoEncodingProperties Copy();
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSession {
    MediaRotation PlaybackRotation { get; set; }
    MediaPlaybackSessionOutputDegradationPolicyState GetOutputDegradationPolicyState();
  }
  public sealed class MediaPlaybackSessionOutputDegradationPolicyState
  public enum MediaPlaybackSessionVideoConstrictionReason
  public sealed class MediaPlayer : IClosable {
    AudioStateMonitor AudioStateMonitor { get; }
  }
}
namespace Windows.Media.SpeechSynthesis {
  public enum SpeechAppendedSilence
  public enum SpeechPunctuationSilence
  public sealed class SpeechSynthesizerOptions {
    SpeechAppendedSilence AppendedSilence { get; set; }
    SpeechPunctuationSilence PunctuationSilence { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
  public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class CellularApnContext {
    string ProfileName { get; set; }
  }
  public sealed class ConnectionProfileFilter {
    IReference<Guid> PurposeGuid { get; set; }
  }
  public sealed class WwanConnectionProfileDetails {
    WwanNetworkIPKind IPKind { get; }
    IVectorView<Guid> PurposeGuids { get; }
  }
  public enum WwanNetworkIPKind
}
namespace Windows.Networking.NetworkOperators {
  public sealed class ESim
  public sealed class ESimAddedEventArgs
  public enum ESimAuthenticationPreference
  public sealed class ESimDownloadProfileMetadataResult
  public static class ESimManager
  public sealed class ESimOperationResult
  public enum ESimOperationStatus
  public sealed class ESimPolicy
  public sealed class ESimProfile
  public enum ESimProfileClass
  public struct ESimProfileInstallProgress
  public sealed class ESimProfileMetadata
  public enum ESimProfileMetadataState
  public sealed class ESimProfilePolicy
  public enum ESimProfileState
  public sealed class ESimRemovedEventArgs
  public sealed class ESimServiceInfo
  public enum ESimState
  public sealed class ESimUpdatedEventArgs
  public sealed class ESimWatcher
  public enum ESimWatcherStatus
  public sealed class MobileBroadbandAntennaSar {
    public MobileBroadbandAntennaSar(int antennaIndex, int sarBackoffIndex);
  }
  public sealed class MobileBroadbandModem {
    bool IsInEmergencyCallMode { get; }
    event TypedEventHandler<MobileBroadbandModem, object> IsInEmergencyCallModeChanged;
    IAsyncOperation<MobileBroadbandPco> TryGetPcoAsync();
  }
  public sealed class MobileBroadbandModemIsolation
  public sealed class MobileBroadbandPco
  public sealed class MobileBroadbandPcoDataChangeTriggerDetails
  public enum NetworkOperatorDataUsageNotificationKind
  public sealed class NetworkOperatorDataUsageTriggerDetails
  public sealed class TetheringEntitlementCheckTriggerDetails
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocket : IClosable, IWebSocket {
    IAsyncOperationWithProgress<uint, uint> SendFinalFrameAsync(IBuffer data);
    IAsyncOperationWithProgress<uint, uint> SendNonfinalFrameAsync(IBuffer data);
  }
  public sealed class ServerMessageWebSocket : IClosable
  public sealed class ServerMessageWebSocketControl
  public sealed class ServerMessageWebSocketInformation
  public sealed class ServerStreamWebSocket : IClosable
  public sealed class ServerStreamWebSocketInformation
}
namespace Windows.Networking.Vpn {
  public sealed class VpnChannel {
    object CurrentRequestTransportContext { get; }
    void AddAndAssociateTransport(object transport, object context);
    ControlChannelTriggerStatus GetSlotTypeForTransportContext(object context);
    void ReplaceAndAssociateTransport(object transport, object context);
    void StartReconnectingTransport(object transport, object context);
    void StartWithTrafficFilter(IIterable<HostName> assignedClientIpv4Addresses, IIterable<HostName> assignedClientIpv6Addresses, VpnInterfaceId vpninterfaceId, VpnRouteAssignment assignedRoutes, VpnDomainNameAssignment assignedNamespace, uint mtuSize, uint maxFrameSize, bool reserved, IIterable<object> transports, VpnTrafficFilterAssignment assignedTrafficFilters);
  }
  public sealed class VpnPacketBuffer {
    object TransportContext { get; set; }
  }
}
namespace Windows.Security.Authentication.Identity.Provider {
  public enum SecondaryAuthenticationFactorAuthenticationMessage {
    CanceledByUser = 22,
    CenterHand = 23,
    ConnectionRequired = 20,
    DeviceUnavailable = 28,
    MoveHandCloser = 24,
    MoveHandFarther = 25,
    PlaceHandAbove = 26,
    RecognitionFailed = 27,
    TimeLimitExceeded = 21,
  }
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class FindAllAccountsResult
  public enum FindAllWebAccountsStatus
  public static class WebAuthenticationCoreManager {
    public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider);
    public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider, string clientId);
    public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId);
    public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId, string authority);
    public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId, string authority, User user);
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public sealed class WebProviderTokenRequest {
    string ApplicationPackageFamilyName { get; }
    string ApplicationProcessName { get; }
    IAsyncOperation<bool> CheckApplicationForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.Security.Credentials {
  public sealed class WebAccountProvider {
    bool IsSystemProvider { get; }
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRouteDrivingOptions {
    IReference<DateTime> DepartureTime { get; set; }
  }
  public sealed class PlaceInfo {
    public static PlaceInfo CreateFromAddress(string displayAddress);
    public static PlaceInfo CreateFromAddress(string displayAddress, string displayName);
  }
}
namespace Windows.Services.Store {
  public sealed class StoreCanAcquireLicenseResult
  public enum StoreCanLicenseStatus
  public sealed class StoreContext {
    bool CanSilentlyDownloadStorePackageUpdates { get; }
    IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseAsync(string productStoreId);
    IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseForOptionalPackageAsync(Package optionalPackage);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> DownloadAndInstallStorePackagesAsync(IIterable<string> storeIds);
    IAsyncOperation<IVectorView<StoreQueueItem>> GetAssociatedStoreQueueItemsAsync();
    IAsyncOperation<StoreProductQueryResult> GetStoreProductsAsync(IIterable<string> productKinds, IIterable<string> storeIds, StoreProductOptions storeProductOptions);
    IAsyncOperation<IVectorView<StoreQueueItem>> GetStoreQueueItemsAsync(IIterable<string> storeIds);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackagesAsync(IIterable<string> storeIds, StorePackageInstallOptions storePackageInstallOptions);
    IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageAsync(Package package);
    IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageByStoreIdAsync(string storeId);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadAndInstallStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
    IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageAsync(Package package);
    IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageByStoreIdAsync(string storeId);
  }
  public sealed class StorePackageInstallOptions
  public sealed class StorePackageUpdateResult {
    IVectorView<StoreQueueItem> StoreQueueItems { get; }
  }
  public sealed class StoreProductOptions
  public sealed class StoreQueueItem
  public sealed class StoreQueueItemCompletedEventArgs
  public enum StoreQueueItemExtendedState
  public enum StoreQueueItemKind
  public enum StoreQueueItemState
  public sealed class StoreQueueItemStatus
  public sealed class StoreUninstallStorePackageResult
  public enum StoreUninstallStorePackageStatus
}
namespace Windows.Storage {
  public sealed class StorageFolder : IStorageFolder, IStorageFolder2, IStorageFolderQueryOperations, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
    StorageLibraryChangeTracker TryGetChangeTracker();
  }
}
namespace Windows.Storage.Provider {
  public interface IStorageProviderUriSource
  public sealed class StorageProviderGetContentInfoForPathResult
  public sealed class StorageProviderGetPathForContentUriResult
  public enum StorageProviderUriSourceStatus
}
namespace Windows.Storage.Search {
  public sealed class StorageLibraryChangeTrackerTriggerDetails
}
namespace Windows.System {
  public sealed class AppActivationResult
  public sealed class AppDiagnosticInfo {
    IAsyncOperation<AppActivationResult> LaunchAsync();
  }
  public sealed class AppExecutionStateChangeResult
  public sealed class AppResourceGroupInfo {
    IAsyncOperation<AppExecutionStateChangeResult> StartResumeAsync();
    IAsyncOperation<AppExecutionStateChangeResult> StartSuspendAsync();
    IAsyncOperation<AppExecutionStateChangeResult> StartTerminateAsync();
  }
  public enum AutoUpdateTimeZoneStatus
  public static class TimeZoneSettings {
    public static IAsyncOperation<AutoUpdateTimeZoneStatus> AutoUpdateTimeZoneAsync(TimeSpan timeout);
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticInvoker {
    IAsyncOperationWithProgress<DiagnosticActionResult, DiagnosticActionState> RunDiagnosticActionFromStringAsync(string context);
  }
}
namespace Windows.System.Diagnostics.DevicePortal {
  public sealed class DevicePortalConnection {
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol, uint outboundBufferSizeInBytes, uint maxMessageSize, MessageWebSocketReceiveMode receiveMode);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request, string protocol, uint outboundBufferSizeInBytes, bool noDelay);
  }
  public sealed class DevicePortalConnectionRequestReceivedEventArgs {
    bool IsWebSocketUpgradeRequest { get; }
    IVectorView<string> WebSocketProtocolsRequested { get; }
    Deferral GetDeferral();
  }
}
namespace Windows.System.Inventory {
  public sealed class InstalledDesktopApp : IStringable
}
namespace Windows.System.Profile {
  public static class AnalyticsInfo {
    public static IAsyncOperation<IMapView<string, string>> GetSystemPropertiesAsync(IIterable<string> attributeNames);
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    RemoteSystemPlatform Platform { get; }
  }
  public sealed class RemoteSystemEnumerationCompletedEventArgs
  public enum RemoteSystemPlatform
  public sealed class RemoteSystemWatcher {
    event TypedEventHandler<RemoteSystemWatcher, RemoteSystemEnumerationCompletedEventArgs> EnumerationCompleted;
    event TypedEventHandler<RemoteSystemWatcher, RemoteSystemWatcherErrorOccurredEventArgs> ErrorOccurred;
  }
  public enum RemoteSystemWatcherError
  public sealed class RemoteSystemWatcherErrorOccurredEventArgs
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static GlobalizationPreferencesForUser GetForUser(User user);
  }
  public sealed class GlobalizationPreferencesForUser
}
namespace Windows.UI.ApplicationSettings {
  public sealed class AccountsSettingsPane {
    public static IAsyncAction ShowAddAccountForUserAsync(User user);
    public static IAsyncAction ShowManageAccountsForUserAsync(User user);
  }
  public sealed class AccountsSettingsPaneCommandsRequestedEventArgs {
    User User { get; }
  }
}
namespace Windows.UI.Composition {
  public sealed class AnimationController : CompositionObject
  public enum AnimationControllerProgressBehavior
  public sealed class BounceScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class BounceVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class BounceVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public sealed class CompositionContainerShape : CompositionShape
  public sealed class CompositionEllipseGeometry : CompositionGeometry
  public class CompositionGeometry : CompositionObject
  public class CompositionLight : CompositionObject {
    bool IsEnabled { get; set; }
  }
  public sealed class CompositionLineGeometry : CompositionGeometry
  public class CompositionObject : IClosable {
    AnimationController TryGetAnimationController(string propertyName);
  }
  public sealed class CompositionPath : IGeometrySource2D
  public sealed class CompositionPathGeometry : CompositionGeometry
  public sealed class CompositionRectangleGeometry : CompositionGeometry
  public sealed class CompositionRoundedRectangleGeometry : CompositionGeometry
  public class CompositionShape : CompositionObject
  public sealed class CompositionShapeCollection : CompositionObject, IIterable<CompositionShape>, IVector<CompositionShape>
  public sealed class CompositionSpriteShape : CompositionShape
  public enum CompositionStrokeCap
  public sealed class CompositionStrokeDashArray : CompositionObject, IIterable<float>, IVector<float>
  public enum CompositionStrokeLineJoin
  public sealed class CompositionViewBox : CompositionObject
  public sealed class Compositor : IClosable {
    string Comment { get; set; }
    float GlobalPlaybackRate { get; set; }
    public static float MaxGlobalPlaybackRate { get; }
    public static float MinGlobalPlaybackRate { get; }
    BounceScalarNaturalMotionAnimation CreateBounceScalarAnimation();
    BounceVector2NaturalMotionAnimation CreateBounceVector2Animation();
    BounceVector3NaturalMotionAnimation CreateBounceVector3Animation();
    CompositionContainerShape CreateContainerShape();
    CompositionEllipseGeometry CreateEllipseGeometry();
    CompositionLineGeometry CreateLineGeometry();
    CompositionPathGeometry CreatePathGeometry();
    CompositionPathGeometry CreatePathGeometry(CompositionPath path);
    PathKeyFrameAnimation CreatePathKeyFrameAnimation();
    CompositionRectangleGeometry CreateRectangleGeometry();
    CompositionRoundedRectangleGeometry CreateRoundedRectangleGeometry();
    ShapeVisual CreateShapeVisual();
    CompositionSpriteShape CreateSpriteShape();
    CompositionSpriteShape CreateSpriteShape(CompositionGeometry geometry);
    CompositionViewBox CreateViewBox();
    IAsyncAction RequestCommitAsync();
  }
  public sealed class PathKeyFrameAnimation : KeyFrameAnimation
  public sealed class PointLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
  public sealed class ShapeVisual : ContainerVisual
  public sealed class SpotLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
}
namespace Windows.UI.Composition.Core {
  public sealed class CompositorController : IClosable
}
namespace Windows.UI.Composition.Desktop {
  public sealed class DesktopWindowTarget : CompositionTarget
}
namespace Windows.UI.Composition.Diagnostics {
  public sealed class CompositionDebugHeatMaps
  public enum CompositionDebugOverdrawContentKinds : uint
  public sealed class CompositionDebugSettings
}
namespace Windows.UI.Composition.Interactions {
  public enum VisualInteractionSourceRedirectionMode {
    CapableTouchpadAndPointerWheel = 3,
    PointerWheelOnly = 2,
  }
}
namespace Windows.UI.Core {
  public enum AppViewBackButtonVisibility {
    Disabled = 2,
  }
  public sealed class CoreComponentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public sealed class CoreIndependentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public interface ICorePointerInputSource2 : ICorePointerInputSource
}
namespace Windows.UI.Input.Core {
  public sealed class RadialControllerIndependentInputSource {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.UI.Input.Inking {
  public sealed class InkDrawingAttributes {
    InkModelerAttributes ModelerAttributes { get; }
  }
  public sealed class InkInputConfiguration
  public sealed class InkModelerAttributes
  public sealed class InkPresenter {
    InkInputConfiguration InputConfiguration { get; }
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.UI.Notifications {
  public sealed class ScheduledToastNotification {
    IReference<DateTime> ExpirationTime { get; set; }
  }
}
namespace Windows.UI.StartScreen {
  public sealed class TileMixedRealityModel {
    TileMixedRealityModelActivationBehavior ActivationBehavior { get; set; }
  }
  public enum TileMixedRealityModelActivationBehavior
}
namespace Windows.UI.Text {
  public sealed class ContentLinkInfo
  public sealed class RichEditTextRange : ITextRange
  public enum TextRangeUnit {
    ContentLink = 32,
  }
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView {
    event TypedEventHandler<CoreInputView, object> XYFocusTransferredToPrimaryView;
    event TypedEventHandler<CoreInputView, CoreInputViewTransferringXYFocusEventArgs> XYFocusTransferringFromPrimaryView;
    bool TryTransferXYFocusToPrimaryView(Rect origin, CoreInputViewXYFocusTransferDirection direction);
  }
  public sealed class CoreInputViewTransferringXYFocusEventArgs
  public enum CoreInputViewXYFocusTransferDirection
}
namespace Windows.UI.WebUI {
  public sealed class WebUIBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public sealed class WebUILaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, ILaunchActivatedEventArgs2, IPrelaunchActivatedEventArgs {
    TileActivatedInfo TileActivatedInfo { get; }
  }
}
namespace Windows.UI.Xaml {
  public sealed class BringIntoViewOptions {
    double HorizontalAlignmentRatio { get; set; }
    double HorizontalOffset { get; set; }
    double VerticalAlignmentRatio { get; set; }
    double VerticalOffset { get; set; }
  }
  public sealed class BringIntoViewRequestedEventArgs : RoutedEventArgs
  public sealed class ElementSoundPlayer {
    public static ElementSpatialAudioMode SpatialAudioMode { get; set; }
  }
  public enum ElementSpatialAudioMode
  public enum FocusVisualKind {
    Reveal = 2,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent BringIntoViewRequestedEvent { get; }
    public static RoutedEvent ContextRequestedEvent { get; }
    KeyboardAcceleratorPlacementMode KeyboardAcceleratorPlacementMode { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementModeProperty { get; }
    DependencyObject KeyboardAcceleratorPlacementTarget { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementTargetProperty { get; }
    DependencyObject KeyTipTarget { get; set; }
    public static DependencyProperty KeyTipTargetProperty { get; }
    event TypedEventHandler<UIElement, BringIntoViewRequestedEventArgs> BringIntoViewRequested;
    virtual void OnBringIntoViewRequested(BringIntoViewRequestedEventArgs e);
    virtual void OnKeyboardAcceleratorInvoked(KeyboardAcceleratorInvokedEventArgs args);
    public static void RegisterAsScrollPort(UIElement element);
  }
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty HeadingLevelProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty HeadingLevelProperty { get; }
    public static AutomationHeadingLevel GetHeadingLevel(DependencyObject element);
    public static void SetHeadingLevel(DependencyObject element, AutomationHeadingLevel value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationHeadingLevel
  public class AutomationPeer : DependencyObject {
    AutomationHeadingLevel GetHeadingLevel();
    virtual AutomationHeadingLevel GetHeadingLevelCore();
  }
  public sealed class AutoSuggestBoxAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider {
    void Invoke();
  }
  public class CalendarDatePickerAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider, IValueProvider
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer, IExpandCollapseProvider
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarButtonTemplateSettings TemplateSettings { get; }
  }
  public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarToggleButtonTemplateSettings TemplateSettings { get; }
  }
  public sealed class ContentLinkChangedEventArgs
  public enum ContentLinkChangeKind
  public sealed class HandwritingPanelClosedEventArgs
  public sealed class HandwritingPanelOpenedEventArgs
  public enum HandwritingPanelPlacementAlignment
  public class HandwritingView : Control
  public class MediaTransportControls : Control {
    bool IsCompactOverlayButtonVisible { get; set; }
    public static DependencyProperty IsCompactOverlayButtonVisibleProperty { get; }
    bool IsCompactOverlayEnabled { get; set; }
    public static DependencyProperty IsCompactOverlayEnabledProperty { get; }
  }
  public class MenuFlyoutItem : MenuFlyoutItemBase {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    MenuFlyoutItemTemplateSettings TemplateSettings { get; }
  }
  public class NavigationView : ContentControl {
    NavigationViewBackButtonVisible IsBackButtonVisible { get; set; }
    public static DependencyProperty IsBackButtonVisibleProperty { get; }
    bool IsBackEnabled { get; set; }
    public static DependencyProperty IsBackEnabledProperty { get; }
    string PaneTitle { get; set; }
    public static DependencyProperty PaneTitleProperty { get; }
    event TypedEventHandler<NavigationView, NavigationViewBackRequestedEventArgs> BackRequested;
    event TypedEventHandler<NavigationView, object> PaneClosed;
    event TypedEventHandler<NavigationView, NavigationViewPaneClosingEventArgs> PaneClosing;
    event TypedEventHandler<NavigationView, object> PaneOpened;
    event TypedEventHandler<NavigationView, object> PaneOpening;
  }
  public enum NavigationViewBackButtonVisible
  public sealed class NavigationViewBackRequestedEventArgs
  public sealed class NavigationViewPaneClosingEventArgs
  public class RefreshContainer : ContentControl
  public sealed class RefreshInteractionRatioChangedEventArgs
  public enum RefreshPullDirection
  public sealed class RefreshRequestedEventArgs
  public sealed class RefreshStateChangedEventArgs
  public class RefreshVisualizer : Control
  public enum RefreshVisualizerOrientation
  public enum RefreshVisualizerState
  public class RichEditBox : Control {
    SolidColorBrush ContentLinkBackgroundColor { get; set; }
    public static DependencyProperty ContentLinkBackgroundColorProperty { get; }
    SolidColorBrush ContentLinkForegroundColor { get; set; }
    public static DependencyProperty ContentLinkForegroundColorProperty { get; }
    ContentLinkProviderCollection ContentLinkProviders { get; set; }
    public static DependencyProperty ContentLinkProvidersProperty { get; }
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
    event TypedEventHandler<RichEditBox, ContentLinkChangedEventArgs> ContentLinkChanged;
    event TypedEventHandler<RichEditBox, ContentLinkInvokedEventArgs> ContentLinkInvoked;
  }
  public class TextBox : Control {
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
  }
  public class TreeView : Control
  public sealed class TreeViewCollapsedEventArgs
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemInvokedEventArgs
  public class TreeViewItemTemplateSettings : DependencyObject
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject
  public enum TreeViewSelectionMode
  public sealed class WebView : FrameworkElement {
    event TypedEventHandler<WebView, WebViewSeparateProcessLostEventArgs> SeparateProcessLost;
  }
  public enum WebViewExecutionMode {
    SeparateProcess = 2,
  }
  public enum WebViewPermissionType {
    ImmersiveView = 6,
    Screen = 5,
  }
  public sealed class WebViewSeparateProcessLostEventArgs
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    string Region { get; set; }
    public static DependencyProperty RegionProperty { get; }
  }
  public class MapElement : DependencyObject {
    bool IsEnabled { get; set; }
    public static DependencyProperty IsEnabledProperty { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public sealed class AppBarButtonTemplateSettings : DependencyObject
  public sealed class AppBarToggleButtonTemplateSettings : DependencyObject
  public sealed class MenuFlyoutItemTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Documents {
  public sealed class ContactContentLinkProvider : ContentLinkProvider
  public sealed class ContentLink : Inline
  public sealed class ContentLinkInvokedEventArgs
  public class ContentLinkProvider : DependencyObject
  public sealed class ContentLinkProviderCollection : IIterable<ContentLinkProvider>, IVector<ContentLinkProvider>
  public sealed class PlaceContentLinkProvider : ContentLinkProvider
}
namespace Windows.UI.Xaml.Input {
  public sealed class FocusManager {
    public static IAsyncOperation<FocusMovementResult> TryFocusAsync(DependencyObject element, FocusState value);
    public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection);
    public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
  }
  public sealed class FocusMovementResult
  public sealed class GettingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
  public sealed class KeyboardAcceleratorInvokedEventArgs {
    KeyboardAccelerator KeyboardAccelerator { get; }
  }
  public enum KeyboardAcceleratorPlacementMode
  public sealed class LosingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
}
namespace Windows.UI.Xaml.Media {
  public sealed class CompositionTarget {
    public static event EventHandler<RenderedEventArgs> Rendered;
  }
  public sealed class RenderedEventArgs
}
namespace Windows.Web.UI {
  public interface IWebViewControl
  public sealed class WebViewControlContentLoadingEventArgs
  public sealed class WebViewControlDeferredPermissionRequest
  public sealed class WebViewControlDOMContentLoadedEventArgs
  public sealed class WebViewControlLongRunningScriptDetectedEventArgs
  public sealed class WebViewControlNavigationCompletedEventArgs
  public sealed class WebViewControlNavigationStartingEventArgs
  public sealed class WebViewControlNewWindowRequestedEventArgs
  public sealed class WebViewControlPermissionRequest
  public sealed class WebViewControlPermissionRequestedEventArgs
  public enum WebViewControlPermissionState
  public enum WebViewControlPermissionType
  public sealed class WebViewControlScriptNotifyEventArgs
  public sealed class WebViewControlSettings
  public sealed class WebViewControlUnsupportedUriSchemeIdentifiedEventArgs
  public sealed class WebViewControlUnviewableContentIdentifiedEventArgs
  public sealed class WebViewControlWebResourceRequestedEventArgs
}
namespace Windows.Web.UI.Interop {
  public sealed class WebViewControl : IWebViewControl
  public sealed class WebViewControlAcceleratorKeyPressedEventArgs
  public enum WebViewControlAcceleratorKeyRoutingStage
  public enum WebViewControlMoveFocusReason
  public sealed class WebViewControlMoveFocusRequestedEventArgs
  public sealed class WebViewControlProcess
  public enum WebViewControlProcessCapabilityState
  public sealed class WebViewControlProcessOptions
}
 

Go to Source

Share this
30 Mar 2018

Build your digital signage business on Windows 10

Author: Rushmi Malaviarachchi
Go to Source

It’s been a busy week at Digital Signage Expo 2018 (DSE) and it’s great to see how the industry continues to innovate and change. All throughout the week, we were excited to see our partners enable digital signage solutions across a range of capabilities, from traditional AV displays to dynamic data-driven signage leveraging Windows 10 and the Azure cloud platform.

Windows 10 offers a simple, scalable, and secure platform for digital signage, and with Azure, you can quickly scale as your business grows. Content management solutions running on Azure provide agility, flexibility, and scale to deploy your content across the world in no time. Building on that, here are some highlights of the great work our partners are doing with digital signage leveraging Windows 10 and Azure.

One of our partners, XOGO, offers a simple digital signage solution through two devices: XOGO Mini 4K and an entry-level device, XOGO Mini.  XOGO Mini 4K is a purpose-built Windows media player appliance that is pre-configured with the XOGO digital signage software. It is a complete turnkey solution that can turn any display into a digital sign within minutes. XOGO is also introducing an entry-level device, called XOGO Mini, running Windows 10 IoT Core on a Qualcomm Snapdragon 410 processor, to provide a high-quality, 1080p resolution display at an entry-level price. It is a true plug-and-play solution, ideal for small to medium-sized businesses. XOGO Mini is now available to pre-order here.

We also have partners such as Advantech and iBASE that have enabled commercial-grade media players based on Windows 10, which are ideal for multiple screens or demanding environmental conditions such as airports or shopping malls.

XOGO Mini 4Kdevice

XOGO Mini 4K

Advantech Mini PC

Advantech Mini PC

iBase Media Player

iBase Media Player

Here are some additional examples of great solutions from our partners:

  • Cloverleaf shelfPoint engages retail shoppers at shelf level with dynamic content tailored to individual customers, bringing online advantages to brick-and-mortar stores. Pilot customers have seen significant gains in profits and shopper engagement.
  • Omnivex Moxie is a platform which integrates with existing data sources, line-of-business software, and cloud services to share real-time information across any screen. It delivers multiple benefits including enhanced productivity and better business agility in diverse scenarios such as healthcare, retail, travel, and manufacturing.
  • StratosMedia has created an innovative digital communications platform capable of integrating with virtually any data source and working with multiple types of devices including smartphones, kiosks, and video walls, that makes it easy for organizations of any size to broadcast engaging, high-quality content and get back advanced analytics.

No matter where you are on your digital signage journey, Microsoft has a solution for your needs. To learn more, visit aka.ms/digitalsignage or contact us at MSDigitalSignageSol@microsoft.com.

Build your digital signage business on Windows 10

Tweet This

Go to Source

Share this
29 Mar 2018

8 Hard Truths for SMBs not Worried About Data Recovery and Business Continuity

 

 
8 Cold Hard Truths for SMBs Not Worried About Disaster Recovery and Business Continuity
 
The foundation of any successful business continuity solution is the ability to retrieve data from any point in time from anywhere. When the topic of data recovery and business continuity comes up, you get the feeling that many decision makers at smaller businesses and organizations wish they could channel their inner six year old, simply cover their ears, and sing “La, la, la. I Can’t Hear You. I’m Not Listening.”
 
Everybody thinks bad things only happen to other people. Just because we hear about a fatal car accident on the morning news, doesn’t mean we fixate on that news when we ourselves get into a car and drive to work.
 
So no matter how many times the owner or executive of a small to midsize business (SMB) hears of other small businesses being crippled by hurricanes, tornados, fires, or flooding, they aren’t necessarily overcome with fear to the point that they feel an urgency to take action.
 
Sure, they may think about backup and data recovery solutions a little more that day, but not enough to initiate immediate change or reverse a lenient approach to their processes.
 
If you fall into this category, here are eight cold hard truths to consider
  • It isn’t natural disasters or catastrophic losses like fires that take down small businesses but something far more sinister – malware. Cyber attacks through malware have grown exponentially in the past four years. Malware is hitting everything from PCs to Macs to mobile devices and it’s inflicting damage.
  • Over half of the small businesses in the U.S. have experienced disruptions in day-to-day business operations. 81% of these incidents have led to downtime that has lasted anywhere from one to three days.
  • According to data compiled by the Hughes Marketing Group, 90% of companies employing less than 100 people spend fewer than eight hours a month on their business continuity plan.
  • 80% of businesses that have experienced a major disaster are out of business within three years. Meanwhile, 40% of businesses impacted by critical IT failure cease operations within one year. 44% of businesses ravaged by a fire fail to ever reopen, and only 33% of those that do reopen survive any longer than three years.
  • Disaster recovery solution providers estimate that 60% to 70% of all business disruptions originate internally – most likely due to hardware or software failure or human error.
  • 93% of businesses unable to access their data center for ten or more days filed for bankruptcy within twelve months of the incident.
  • In the United States alone, there are over 140,000 hard drive crashes each week.
  • 34% of SMBs never test their backup and recovery solutions – of those who do, over 75% found holes and failures in their strategies.
It’s critical that small businesses review their backup and disaster recovery processes and take business continuity seriously. Given the vulnerabilities associated with the cloud and workforce mobility, the risk of critical data loss today is quite serious and firms must be truly prepared for the unexpected.
 
Contact us at 
Share this
29 Mar 2018

Announcing Windows 10 Insider Preview Build 17634 for Skip Ahead

Author: Dona Sarkar
Go to Source

Hello Windows Insiders!

Today, we are releasing Windows 10 Insider Preview Build 17634 (RS5) to Windows Insiders who have opted into Skip Ahead.

What’s new in Build 17634

Search is now available in Calendar for Windows 10!

Now you can find past or future events by searching for the name, location, people included or words in the event body. Events that match your search will be clearly visible on your calendar, while those that don’t will be greyed-out so you can find what you need quickly.

Find past or future events by searching for the name, location, people included or words in the event body in Calendar for Windows 10.

Search will work for Outlook, Hotmail, Live and Office 365 accounts. We do not yet support searching Exchange Server, Gmail, Yahoo or other IMAP calendars.

Cortana Show Me now supports voice queries

Last week, we introduced Cortana Show Me, a preview app designed to show you around Windows 10 settings. We’re here with some updates to try – you can now launch the app through voice queries. Simply say to Cortana, “Show me how to change my background,” and you’ll get the previous help results, with a new “Let’s go” button below, which launches the guided help experience. Everything else is the same as last week – the app is available in English (US and Great Britain) and in German, and there are 15 settings guides. While most Insiders don’t need pointers like this, it’s for all the friends and family we have who need a pointer – please share it with them.

You can download Cortana Show Me from Microsoft Store.

Note: If you’re using keyboard navigation with your device, you will need to use Alt + Tab to move between Settings and Cortana Show Me.

Here are some voice queries to try:

  • Update Windows – Try, “Update my Windows device”
  • Check if an app is installed – Try, “How to see what apps are installed”
  • Uninstall an app – Try “How to uninstall apps”
  • Change your desktop background – Try, “Show me how to change my background”
  • Use Airplane Mode – Try, “How do I turn on airplane mode”
  • Change your display brightness – Try, “Show me how to change my screen brightness”
  • Add nearby printers or scanners – Try, “How to add a printer”
  • Turn off Windows Defender Security Center – Try, “Show me how to turn off Windows Defender Security Center”
  • Change Wi-Fi settings – Try, “Show me how to change Wi-Fi network”
  • Change your power settings – Try, “How to change when my computer goes to sleep”
  • Discover Bluetooth devices – Try, “Show me how to discover devices”
  • Check your version of Windows – Try, “How do I find my current version of Windows”

General changes, improvements, and fixes for PC

  • We fixed an issue where typing in the Microsoft Edge URL bar immediately after opening a new tab might result in the letters appearing in an unexpected order.
  • We fixed an issue when opening .html or .pdf files from the local system (double-click, right-click > open), Microsoft Edge will not render the loaded content if Microsoft Edge wasn’t already running before opening the file.
  • We fixed an issue where PDFs displayed using Microsoft Edge would shrink after refreshing the page when using a DPI scaling > 100%.
  • We fixed an issue that could result in Microsoft Edge crashing when turning off certain extensions.
  • We fixed an issue resulting in Task Manager not showing the application title in the process name for open Visual Studio projects.
  • We fixed an issue resulting in the UAC dialog potentially not rendering correctly in the last few flights.
  • We fixed an issue resulting in certain devices with BitLocker enabled unexpectedly booting into BitLocker recovery in recent flights.
  • We fixed an issue where the Emoji Panel would close after typing an accent in certain languages.
  • We fixed an issue resulting in focus being lost after using WIN+A to close the Action Center.

Known issues

  • If you open Settings and clicking on any links to the Microsoft Store or links in tips, Settings will crash. This includes the links to get themes and fonts from the Microsoft Store, as well as the link to Windows Defender.
  • On resuming from sleep, the desktop may be momentarily visible before the Lock screen displays as expected.
  • When Movies & TV user denies access to its videos library (through the “Let Movies & TV access your videos library?” popup window or through Windows privacy settings), Movies & TV crashes when the user navigates to the “Personal” tab.

REMINDER: Sign up to be an Office Insider!

Our friends on the Office team want to reiterate their invitation for Windows Insiders to participate in feedback and product usage which will inform the next generation of Office innovations! Windows and Office are continually looking for the best-connected experiences. Your feedback is extremely valuable to us and will help us to understand customer needs and scenarios and to prioritize our investments in the coming months. Please join the Office Insider Program to help directly affect product design decisions!

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

Go to Source

Share this
29 Mar 2018

Here’s how Burton Snowboards is creating products for riders around the globe

Author: Dan Laycock
Go to Source

Chris working through the design process on a Surface Studio.

Chris working through the design process on a Surface Studio.

Burton has been synonymous with the sport of snowboarding for decades. Since the company’s founding, Snowboarding has grown and evolved, even becoming an Olympic sport in 1998. Burton has been a key piece of the sport’s growth and transformation at every step. As the company looks ahead to emerging trends in the sport and charts its own transformation, we sat with Burton’s head of product, Chris Cunningham, to hear about how they create new products for riders around the globe and how Surface is coming into the process.

Chris Cunningham, Head of Product for Burton

Chris Cunningham, Head of Product for Burton

Tell us about yourself. What do you do? How did this kind of work find you? What keeps you coming back every day?

My name is Chris Cunningham, and I am the Senior Vice President of Global Product here at Burton Snowboards.

For some background… I was born and raised in the midwest (Indiana) and discovered snowboarding back in ‘91 when I was in seventh grade.  I fell in love with the sport and have been snowboarding ever since.  I come from an artistic family/background and tend to think like an engineer, but ultimately ended up going to business school (all due to proximity to the local ski hill).

I joined Burton after graduating from Indiana University in 2000 and started in customer service with the goal to eventually work my way into the product department.  By 2002, I landed my first ‘product’ job as an Assistant Product Manager of Bindings.  From there I ascended the ranks of Product Manager, Category Manager, Director, Vice President, etc.  Today, I oversee the entire Product Division for Burton that includes all categories and teams that are responsible for developing Burton’s product lines – from R&D through validation and production.

What keeps me and many others coming back each and every day is the continuous pursuit to make better product.  You’re only as good as your last product line, and there is always the next revision, innovation, or leap forward around the corner.  Having the opportunity to constantly work on products you love and use, and then obsess about how to make them better, then actually making it happen is my dream job. Burton is also just an amazing place to work…great people, vibe, etc.

Burton is a leader in the industry, building both apparel and equipment for athletes and riders. In your opinion, what drives the company’s success?

I think this is best answered by ‘The Burton Stance’ (image below).  Put simply; we are a passionate group of riders that focus on what is best for riders.  When you put the user at your focal point (this can be a pro snowboarder, average snowboarder, or even a beginner) the rest will follow.  We are in it for the snowboarding, and I think that gives us an advantage.

“The Burton Stance”

“The Burton Stance”

Where do you get your creative inspiration?

Inspiration can come in many forms. Our creative teams pull from anything and everything that might provoke their interest.  This can range from art, music, industrial design, architecture, furniture, fashion, etc. Creativity extends through the technical fundamentals of a product to the graphics. More than most outdoor gear, a snowboard presents a canvas for some amazing graphics design.

We use both trend (WGSN) and consulting (Camp High Collective) services to help pull ourselves out of our comfort zone. We also simply work with a lot of talented and creative individuals that like to push themselves creatively.  Sometimes getting inspiration can simply come from turning to your colleague, seeing what they are working on, and it sparks the next idea for your own category. Last, but not least, we pull inspiration from our professional team of riders.  These individuals are at the forefront of what is happening in the world of snowboarding; simply listening to their interest, ideas, and needs, can quickly inspire our design teams.

What has your creative approach been? Tell us about your creative workflow; going from idea to product historically.

The workflow can vary from category to category, but the overall process isn’t too different between Hardgoods (products like snowboards, bindings, boots) and Softgoods (outerwear, accessories, backpacks).  We like to kick off the season with what we call a ‘seasonal lens’ that helps us frame both our creative and business intents for the season.  This lays down the foundation we work from.

From there, new products and designs are briefed-in from our line planners to our Creative and Design teams.  Ideas and concepts are then sketched and comped and the iterative process between designers, merchandising, engineering, etc. begins.  We have a general stage gate process we move the work through until we get to a final design or proof of concept.  From there, our proto and development teams come into the picture and start to turn concepts into actual prototypes we can touch and feel, and eventually validate through lab and on-snow testing.  After a few more rounds, we eventually get to a final design and specification we feel confident can move into manufacturing/commercialization.

Obviously, the complexity of the product or project can vary the timing of this process from just a few months to multiple years.

Chris Cunningham and Chris Doyle in Burton’s prototype lab.

Chris Cunningham and Chris Doyle in Burton’s prototype lab.

What excites you most about adding Surface devices into this process? What do you feel these products will allow your team to do that was either difficult or impractical previously?

We love to add new tools into our toolbox, and both the Surface Pros and Studios have been welcomed additions.  The Surface Pro are such powerful little machines.  While at my desk, it’s an extremely powerful and capable PC.  When up and walking about the office, it becomes a useful tablet helpful in capturing notes, sharing ideas, presenting plans, etc.  Our engineering and ID teams are using Surface Studios to explore new ways to work in 3D design.  In many cases, the mouse is becoming obsolete, and I even had one design engineer suggest she might ‘ditch her keyboard altogether’ and just work from the screen.

In either case, I think what Surface allows for a more immersive experience into the work on screen.  It’s no longer point, click, type.  It all about zoom, flip, scale, rotate, shade, draw, etc.

Chris and his team in a creative meeting where ideas are sketched.

Chris and his team in a creative meeting where ideas are sketched.

How has the sport changed during your tenure? With this in mind, how you approach reinventing and innovating something as well-known and well-loved as the snowboard?

Since joining Burton, the sport has only continued to evolve, and on so many fronts. Riders continue to progress to levels once thought never possible and with that, the expectations of the product progress as well. That is always a welcomed challenge for our teams. What’s less obvious is that over time the products we make for beginner riders and kids have made the sport far more accessible to anyone who wants to learn, and from a product perspective, that’s exciting too.  Just the fundamentals of making product lighter, stronger, faster, can keep us coming back to the table ready to reinvent and innovate.  As stated above, you’re only as good as your last product line, so the question of ‘how can we make it even better?’ always exists.

Person carrying a Surface device

Go to Source

Share this
28 Mar 2018

Private audience: A new way to test your apps and games in production

Author: Dev Center Team
Go to Source

One of the consistent themes that the Dev Center Team hears from the Windows developer community is that first impressions are important. Before launching a new app or game, it’s important to validate that the experience is working perfectly in production. At the same time, many developers may have disclosure concerns and want to control the announcement timing of new products. We’ve heard your feedback that testing in production before launch is critical to gain confidence in your products’ quality, and that you’d like to be able to do this testing without having the product visible to anyone beyond the intended audience.

To address this feedback, we’ve added a private audience capability in Dev Center. This new option is available now to all developers and allows you to publish an app or game that will be visible only the people you specify. No one else will be able to see that the product exists in the Microsoft Store, even if they somehow have a direct link to the Microsoft Store listing. This lets you validate the experience with the audience of your choosing, while keeping the product hidden from everyone else until you are ready to make the it visible to the public.

How does it work?  

Private audience uses known user groups (the same type of groups as with package flighting), and membership of these groups can be managed directly in Dev Center, without requiring the product to be republished every time you add or remove someone from the group. Only people in the groups you define who are authenticated with a Microsoft account will be able to see the app in the Microsoft Store. Any reviews left in the Store by your group members will be visible in Dev Center, but won’t appear on your Store listing.

How do I use it?

You can select which of your known users groups to make your new app or game visible to in the Visibility section of the Pricing and availability page of your submission. Additional known users can be added to your groups at any time, without requiring a new submission to change the members of the audience.

Private audience feature in Dev Center.

After you publish to a private audience, you can make the app or game publicly visible whenever you’re ready. If you’d like the app or game to automatically transition from private audience to public audience at a specific time, without having to come back and create a new submission, you can specify a date when it should be made public. You can also create a new submission and change the Audience setting to Public audience at any time. Note that the private audience option is only available for new submissions – once a product has already been published to a public audience, you can’t switch it back to private audience.

Other tips to help test your app

Since the private audience option only affects who can get the product and see it in the Microsoft Store, you can use this option in conjunction with other features to help ensure that only quality experiences are delivered to your customers, particularly as you increase the size of the audience who can see your product. For example, while your app is visible only to your private audience, you can add package flights to deliver new builds to a subset of that audience, and use gradual rollout to slowly roll out new builds to each flight or to everyone who currently has your app. The investment you put into validating your build quality with your flight audiences will already be in place when the time comes to make the product visible to everyone.

If confidentiality is a concern, keep in mind that although private audience will restrict the app’s visibility to only the people you specify, you’ll want to clearly communicate to those people that you are trusting them not to disclose information about the app via sharing screenshots or mentioning it on social media. Also make sure that your services, including Xbox Live if you are using it, aren’t advertising the existence of the app.  And although reviews left in the Store are shown only in the Reviews report in Dev Center, feedback left via Feedback Hub will be visible to everyone, so make sure your testers get you their input in some other way.

You can read more about the new private audience capability in our documentation. As you use this feature, please let us know what you think by using by giving us feedback in Dev Center (via the icon near the top of each page). And please let us know what features you’d like next using the Windows Platform UserVoice for Dev Center. Your feedback helps us identify areas of future focus!

Go to Source

Share this
27 Mar 2018

Eight ways to save during the Microsoft Store Spring Sale

Author: Elana Pidgeon
Go to Source

  1. Save $200 on Surface Pro i5 devices**

Surface Pro i5 devices

Spring means sunny days spent outdoors are ahead, so why not upgrade and save on Surface Pro i5 128GB and Pro i5 256GB. This ultra-light and versatile laptop has the power and performance that lets you to work and play from anywhere you want. Offer ends April 7.

  1. Get 20% off the Surface Arc Mouse

If you’re interested in a new Surface Pro, then you want an equally sleek new Surface Arc Mouse at a great price. Available in burgundy, cobalt blue, and light gray, it’s the perfect partner for your Surface. This slim, light Bluetooth mouse snaps flat to easily fit in your bag or pocket and offers both horizontal and vertical scrolling. Offer ends April 9.

  1. Save up to 50% on PC Games for Windows

Save on select popular Windows 10 games during Spring Sale. Many games including Forza Motorsport 7, Cuphead, ARK: Survival Evolved, and Gears of War 4 support Xbox Play Anywhere, where one purchase gets you the game on both Xbox One and Windows 10 with cross save capability (PC hardware requirements may vary for games on Windows 10).

Looking for something a little less intense but equally exciting? Check out our collection of free to play games for Windows with savings on in-game add-ons including Caesars Slots, Pirates & Pearls, The Tribez, Asphalt 8, and more. PC Game offers available online only and end April 2.

  1. Save up to 75% on apps

Discover great deals on select apps for Windows 10 that will help you embrace your creative side and enable your creativity. Save money and enhance your photos with Polarr Pro, make your own music with Djay Pro, and make epic videos with Movie Edit Pro Plus Windows Store Edition. You can also save up to 50% on select apps for Xbox like Nitrado, Dolby Atmos, AirServer Xbox Edition, and more during Spring Sale. Apps offers available online only and end April 2.

  1. Save up to $500 on select Windows 10 PCs***

Windows 10 PCs

Looking for a new PC? Save up to $500 this Spring when you purchase select Windows 10 PCs. Find deals on select versatile and powerful laptops, 2-in-1s, gaming PCs, and desktops from Acer, Alienware, ASUS, Dell, HP, Lenovo, MSI, Razer Blade, and more. There’s also deals on select keyboards, mice, headsets, and more. These deals end April 2.

  1. Save up to $100 on Windows Mixed Reality Headsets****

Mixed Reality Headset

Now is a great time to get select Windows Mixed Reality headsets with motion controllers from Acer, Dell, HP, and Lenovo.  Immerse yourself in a new reality that features a wide range of epic experiences. Select headsets with motion controllers start at $299 and offers are available through April 2.

You can also find deals on incredible select mixed reality content including games like Luna, Defend the Bits VR, and Arizona Sunshine as well as apps like The Blu: Season 1 and Hello Mars. Mixed reality games and apps offers are only available online and end April 2.

  1. Save up to 80% on great ebooks

ebooks

Spring is the perfect time to find a sunny spot and enjoy captivating ebooks like Verbal Judo and This is Just My Face, or discover new recipes in Barbecue Sauces, Rubs, and Marinades–Bastes, Butters & Glazes, Too.  Find deep discounts on over 100 great ebooks during our Spring Sale. Offers are for a limited time and end date varies by title.

  1. Get up to 60% of hit movies and TV shows

Movies and TV shows

Need a little down time to relax or a respite from Spring showers? Stay entertained and save up to 60% on hit movies including Blade Runner 2049, Planet of the Apes trilogy, and The Lego Ninjago Movie and binge worthy TV shows like The Flash, Preacher, and This is Us.  From new releases to movie bundles to TV season passes, you won’t want to miss these deals, available for both Windows and Xbox. Movies & TV offers available online only and end April 2.

Visit your local Microsoft Store or go online to Microsoft.com/Store to take advantage of these deals before Spring Sale ends on April 2.

* Offers valid March 27, 2018 to April 2, 2018 on select apps, games, books, movies & TV shows available through Microsoft Store. Offers and content varies by market and may change at any time.
** Offer valid from 9:00 PM PST on March 17, 2018 to 11:59 PM PST on April 7, 2018, while supplies last. Available only in Microsoft retail and online store in the United States (including Puerto Rico). Offer valid only on select Surface Pro i5 device..
*** Offer valid from March 27, 2018 to April 2​​​, 2018, while supplies last. Available only in Microsoft retail and online store in the United States (including Puerto Rico) and Canada. Offer valid only on select PCs..
**** Offer valid from 9:00 PM PST on March 26, 2018 to 11:59 PM PST on April 2, 2018, while supplies last. Available only in Microsoft retail and online store in the United States (including Puerto Rico) and Canada. Offer valid only on select Microsoft Mixed Reality Headsets with Motion Controllers.
Offers not valid on prior orders or purchases; cannot be transferred or otherwise redeemed for cash or promo code(s). May not be combinable with other offers. Refunds will take into account the discount. Price discount does not include taxes, shipping or other fees. Void where prohibited or restricted by law. Microsoft reserves the right to modify or discontinue offers at any time. Limit of 5 offers per customer. Other exclusions and limits may apply. See store associate for details for offers on select Surface Pro i5 devices, PC’s, and Microsoft Mixed Reality Headsets with Motion Controllers, which are available in retail stores.

Go to Source

Share this
27 Mar 2018

Announcing Windows 10 Insider Preview Build 17133 for Fast

Author: Dona Sarkar
Go to Source

UPDATE 4/5: We have released Windows 10 Insider Preview Build 17133 (RS4) to Windows Insiders in the Release Preview ring. Not all Insiders in the Release Preview ring will be immediately targeted to receive this flight. We are targeting full availability to Release Preview Monday 4/9 however if you’d like to install immediately, a manual check for updates under Settings > Update & Security > Windows Update will present the build.

UPDATE 3/30: We have released Windows 10 Insider Preview Build 17133 (RS4) to Windows Insiders in the Slow ring. As part of this flight, we are testing the engineering systems responsible for the deployment of Windows 10 feature updates to customers. As such, not all Insiders in the Slow ring will be immediately targeted to receive this flight. We are targeting full availability to the Slow ring on Monday 4/2 however, if you’d like to install immediately, a manual check for updates under Settings > Update & Security > Windows Update will present the build.

NOTE: It will be listed as “Feature update for Windows 10, version 1803”.

Hello Windows Insiders!

Today, we are releasing Windows 10 Insider Preview Build 17133 (RS4) to Windows Insiders in the Fast ring.

Just like in Build 17128, you will also notice that the watermark at the lower right-hand corner of the desktop has disappeared in Build 17133. Again, we are in the phase of checking in final code to prepare for the final release.

General changes, improvements, and fixes for PC

  • We fixed an issue resulting in certain devices with BitLocker enabled unexpectedly booting into BitLocker recovery in recent flights.
  • We fixed an issue resulting in not being able to change the display resolution when there were 4 or more monitors connected, due to the confirmation prompt hanging when you selected “Keep changes”.
  • We fixed an issue where clicking suggested search terms when typing in the Microsoft Edge URL bar didn’t do anything.

Known issues

  • There are currently no major known issues for this flight however if any issues are discovered based off Insider feedback, we’ll add them here.

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

Go to Source

Share this
22 Mar 2018

The Sky’s the Limit for SMBs Taking to the Cloud

 
 
The Sky’s the Limit for SMBs Taking to the Cloud
 
There has been a lot of hype about cloud computing transforming the way small-to-medium sized businesses do business. Proponents of the cloud say that cloud computing has leveled the playing field, allowing SMBs to finally compete with bigger companies despite their limited financial resources and staffing.
 
Still, many are apprehensive to make the jump. They’re hesitant to give up control and they fear the cloud will expose them to greater security risks. Moving to the cloud definitely requires a leap of faith, but a recent ComScore study, completed on behalf of Microsoft, suggests that those who are froggy enough to take the leap (sorry) have no regrets once they do.
 
In fact, more than half of those surveyed wish they had adopted it earlier and feel that the benefits far outweigh their initial worries.
 
What are those benefits?
 
Enhanced Privacy and Security
 
According to the study, 94 percent of companies who’ve adopted cloud services believe they’re now more secure than they were before, thanks to the cloud’s spam management and up-to-date systems and antivirus protection.
 
Less Downtime and More Confidence
 
61% of those surveyed reported fewer instances of downtime since their move to the cloud. Even those who still experienced downtime events felt that they were shorter in duration and that full recovery could be achieved much quicker.
 
93% indicated that they were more confident in their ability to fully recover after an outage. Comparatively, 73% responded that they felt the integrity of their data in the cloud was stronger than previously, which is interesting since data integrity has often been the biggest worry about the cloud.
 
Environmental Friendliness
 
Any company striving to be more “green” will appreciate the environmental benefits of moving to the cloud.  A recent six-month study conducted by the Berkeley Lab found that moving 86 million U.S. office workers to the cloud resulted in the use of 87% less energy, leaving enough leftover electricity annually to power a city the size of Los Angeles for twelve months.
 
Cost Effectiveness
 
Cost effectiveness and greater ROI (return on investment) are the most important factors in getting CEOs and major decision makers to support shifting to the cloud.  A Rackspace commissioned study conducted by Vanson Bourne, found that 62% of respondents felt that adopting cloud computing strategies freed up money that could be reinvested in other operations like marketing, customer service, product development, and expansion into new markets.
 
Conclusion
 
While there is a competitive advantage that can be realized by moving to the cloud, those who are still apprehensive should migrate to the cloud at a pace they’re comfortable with. Once they implement cloud monitoring, and understand it a bit more, most SMBs grow more comfortable with the cloud and expand their use of it.
 
Contact us at 
Share this
15 Mar 2018

Why Should You Get On The Cloud?

 

 
A recent article by The Guardian (UK) states that the cloud industry is set to see a growth of around 30% soon. But many small and medium business owners are still struggling to make sense of the cloud and how it can benefit them. If you are one of them, then here’s what’s in store for you when you migrate to the cloud:
 
1. Connectivity – Being on the cloud gives you unparalleled connectivity to your data—from anywhere and at any time. All you need is a device that can connect you to the web and you are set!
 
2. Save On Hardware Costs – Using the cloud for certain programs spares you the cost of investing in specific hardware. Even devices as simple as your smartphone or a tablet can help you access those applications so you don’t have to spend money on dedicated hardware. Studies have shown that cloud users end up enjoying as much as a 17% IT cost reduction compared to their non-cloud counterparts.
 
3. Cloud Enables SAAS – The cloud allows you to use software as a service. Microsoft 365 is one such example. When you use software as a service, you enjoy certain benefits such as more regular updates at a lower cost and the ability to have anyone work on the program for you by sharing the access credentials with them.
 
4. More Efficient Use of IT Staff – Moving to a cloud-based environment puts the burden of maintenance and downtime reduction on your service provider. That means you can use your limited IT staff more efficiently and also don’t have to worry about the costs associated with such maintenance or downtime.
 
5. Improved Productivity – Studies have shown that cloud users enjoy better productivity than their non-cloud counterparts. This could be because cloud service providers are better equipped to handle any IT eventualities than the average SMBs.
 
So, perhaps it’s time to ‘get cloudy’ and enjoy all that the cloud has to offer your SMB. And…if you need help in doing that, we are just a phone call away!

Share this

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

Click Me