November 21, 2016 8:00 am

Windows 10 SDK Preview Build 14965 Released

By / Senior Technical Product Manager

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

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

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

Things to note:

What’s New

Known Issues Windows SDK

  • Wrong GenXBF.DLL
    If you installed a previous Windows SDK flight, either version 14951 or 14931, you may have an incorrect GenXBF.dll installed. Please follow the following steps after installing the Windows 10 SDK Preview build 14965.
  1. Exit Visual Studio
  2. Open an Administrative command prompt
  3. Type the following:

    DEL “c:\Program Files (x86)\Windows Kits\10\bin\x86\genxbf.dll”

    DEL “c:\Program Files (x86)\Windows Kits\10\bin\x64\genxbf.dll”

  1. Run Control Panel
  2. Select Uninstall a Program
  3. Highlight Windows Software Development Kit – Windows 10.0.14965.1000
  4. Click Change
  5. Select Repair
  6. Click Next

Windows SDK setup will restore the missing GenXBF.dlls  with the appropriate version.

  • Visual Studio 2017 fails with HRESULT: 0x80041FE2 when trying to create C++ UWP apps targeting build 14965 SDK

This is a known problem. Here are steps to address this issue in your project file:

  1. Close the project
  2. Open up the project file in notepad or your favorite editor
  3. Add the following to the project file:
      <PropertyGroup><DoBundleInstallationChecks>false</DoBundleInstallationChecks></PropertyGroup>
  4. Reopen the project in Visual Studio

Known Issues Microsoft Emulator

Microsoft Emulator Preview for Windows 10 Mobile (10.0.14965.0) crashes when launching

Impact:

Please note that there is a bug impacting the usage of hardware accelerated graphics in the latest release of the Mobile Emulator. Follow the instructions below to temporarily disable hardware accelerated graphics in the emulator and use the emulator with software rendered graphics (WARP).

NOTE: The following registry setting will impact any and all Microsoft Emulators installed on your machine. You will need to remove this registry setting in order to re-enable hardware accelerated graphics in the emulator.

  1. Create the following registry subkey if it doesn’t exist: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Xde\10.0
  2. Right click the 10.0 folder, point to New, and then click DWORD Value.
  3. Type DisableRemoteFx, and then press Enter.
  4. Double-click DisableRemoteFx, enter 1 in the Value data box, select the Decimal option, and then click OK.

API Updates and Additions

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

namespace Windows.ApplicationModel.Preview.Notes {
  public sealed class NotesWindowManagerPreview {
    void SetFocusToPreviousView();
    IAsyncAction SetThumbnailImageForTaskSwitcherAsync(SoftwareBitmap bitmap);
    void ShowNoteRelativeTo(int noteViewId, int anchorNoteViewId, NotesWindowManagerPreviewShowNoteOptions options);
    void ShowNoteWithPlacement(int noteViewId, IBuffer data, NotesWindowManagerPreviewShowNoteOptions options);
  }
  public sealed class NotesWindowManagerPreviewShowNoteOptions
}
 
namespace Windows.Devices.Gpio {
  public sealed class GpioInterruptBuffer
  public struct GpioInterruptEvent
  public enum GpioOpenStatus {
    MuxingConflict = 3,
    UnknownError = 4,
  }
  public sealed class GpioPin : IClosable {
    GpioInterruptBuffer InterruptBuffer { get; }
    ulong InterruptCount { get; }
    void CreateInterruptBuffer();
    void CreateInterruptBuffer(int minimumCapacity);
    void StartInterruptBuffer();
    void StartInterruptBuffer(GpioPinEdge edge);
    void StartInterruptCount();
    void StartInterruptCount(GpioPinEdge edge);
    void StopInterruptBuffer();
    void StopInterruptCount();
  }
}
namespace Windows.Devices.Gpio.Provider {
  public interface IGpioInterruptBufferProvider
  public interface IGpioPinProvider2
  public struct ProviderGpioInterruptEvent
}
namespace Windows.Devices.I2c {
  public enum I2cTransferStatus {
    ClockStretchTimeout = 3,
    UnknownError = 4,
  }
}
 
namespace Windows.ApplicationModel {
  public sealed class Package {
    IAsyncOperation<PackageContentGroup> GetContentGroupAsync(string name);
    IAsyncOperation<IVector<PackageContentGroup>> GetContentGroupsAsync();
    IAsyncOperation<bool> SetInUseAsync(bool inUse);
    IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names);
    IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names, bool moveToHeadOfQueue);
  }
  public sealed class PackageCatalog {
    event TypedEventHandler<PackageCatalog, PackageContentGroupStagingEventArgs> PackageContentGroupStaging;
    IAsyncOperation<Package> AddOptionalPackageAsync(string optionalPackageFamilyName);
  }
  public sealed class PackageContentGroup
  public sealed class PackageContentGroupStagingEventArgs
  public enum PackageContentGroupState
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    ContactPanel = 1017,
    LockScreenComponent = 1016,
  }
  public sealed class ContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
  public interface IContactPanelActivatedEventArgs
  public sealed class LockScreenComponentActivatedEventArgs : IActivatedEventArgs
  public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IToastNotificationActivatedEventArgs {
    int CurrentlyShownApplicationViewId { get; }
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class GattCharacteristicNotificationTrigger : IBackgroundTrigger {
    public GattCharacteristicNotificationTrigger(GattCharacteristic characteristic, BluetoothEventTriggeringMode eventTriggeringMode);
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
  }
  public sealed class GattServiceProviderTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactAnnotation {
    string ContactGroupId { get; set; }
    string ContactListId { get; set; }
  }
  public enum ContactAnnotationOperations : uint {
    Share = (uint)32,
  }
  public sealed class ContactAnnotationStore {
    IAsyncOperation<IVectorView<ContactAnnotation>> FindAnnotationsForContactGroupAsync(string contactGroupId);
    IAsyncOperation<IVectorView<ContactAnnotation>> FindAnnotationsForContactListAsync(string contactListId);
  }
  public sealed class ContactGroup
  public sealed class ContactGroupMember
  public sealed class ContactGroupMemberBatch
  public sealed class ContactGroupMemberReader
  public enum ContactGroupOtherAppReadAccess
  public static class ContactManager {
    public static IAsyncOperation<bool> IsShowFullContactCardSupportedAsync();
  }
  public sealed class ContactManagerForUser {
    void ShowFullContactCard(Contact contact, FullContactCardOptions fullContactCardOptions);
  }
  public sealed class ContactPanel
  public sealed class ContactPanelClosingEventArgs
  public sealed class ContactPanelLaunchFullAppRequestedEventArgs
  public sealed class ContactPicker {
    User User { get; }
    public static ContactPicker CreateForUser(User user);
    public static IAsyncOperation<bool> IsSupportedAsync();
  }
  public sealed class ContactStore {
    IAsyncOperation<ContactGroup> CreateContactGroupAsync(string displayName);
    IAsyncOperation<ContactGroup> CreateContactGroupAsync(string displayName, string userDataAccountId);
    IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
    IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsByRemoteIdAsync(string remoteId);
    IAsyncOperation<ContactGroup> GetContactGroupAsync(string contactGroupId);
  }
  public sealed class PinnedContactIdsQueryResult
  public sealed class PinnedContactManager
  public enum PinnedContactSurface
}
namespace Windows.ApplicationModel.Core {
  public sealed class CoreApplicationView {
    IPropertySet Properties { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataTransferManager {
    public static void ShowShareUI(ShareUIOptions shareOptions);
  }
  public sealed class ShareUIOptions
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMessage {
    IVector<EmailRecipient> ReplyTo { get; }
    EmailRecipient SentRepresenting { get; set; }
  }
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
  public static class LicenseManager {
    public static IAsyncAction RefreshLicensesAsync(LicenseRefreshOption refreshOption);
  }
  public enum LicenseRefreshOption
}
namespace Windows.ApplicationModel.UserDataAccounts {
  public sealed class UserDataAccount {
    bool CanShowCreateContactGroup { get; set; }
    bool IsProtectedUnderLock { get; set; }
    IPropertySet ProviderProperties { get; }
    IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
    IAsyncOperation<IVectorView<UserDataTaskList>> FindUserDataTaskListsAsync();
    IAsyncOperation<string> TryShowCreateContactGroupAsync();
  }
  public sealed class UserDataAccountStore {
    IAsyncOperation<UserDataAccount> CreateAccountAsync(string userDisplayName, string packageRelativeAppId, string enterpriseId);
  }
}
namespace Windows.ApplicationModel.UserDataTasks {
  public sealed class UserDataTask
  public sealed class UserDataTaskBatch
  public enum UserDataTaskDaysOfWeek : uint
  public enum UserDataTaskDetailsKind
  public enum UserDataTaskKind
  public sealed class UserDataTaskList
  public sealed class UserDataTaskListLimitedWriteOperations
  public enum UserDataTaskListOtherAppReadAccess
  public enum UserDataTaskListOtherAppWriteAccess
  public sealed class UserDataTaskListSyncManager
  public enum UserDataTaskListSyncStatus
  public static class UserDataTaskManager
  public sealed class UserDataTaskManagerForUser
  public enum UserDataTaskPriority
  public enum UserDataTaskQueryKind
  public sealed class UserDataTaskQueryOptions
  public enum UserDataTaskQuerySortProperty
  public sealed class UserDataTaskReader
  public sealed class UserDataTaskRecurrenceProperties
  public enum UserDataTaskRecurrenceUnit
  public sealed class UserDataTaskRegenerationProperties
  public enum UserDataTaskRegenerationUnit
  public enum UserDataTaskSensitivity
  public sealed class UserDataTaskStore
  public enum UserDataTaskStoreAccessType
  public enum UserDataTaskWeekOfMonth
}
namespace Windows.ApplicationModel.UserDataTasks.DataProvider {
  public sealed class UserDataTaskDataProviderConnection
  public sealed class UserDataTaskDataProviderTriggerDetails
  public sealed class UserDataTaskListCompleteTaskRequest
  public sealed class UserDataTaskListCompleteTaskRequestEventArgs
  public sealed class UserDataTaskListCreateOrUpdateTaskRequest
  public sealed class UserDataTaskListCreateOrUpdateTaskRequestEventArgs
  public sealed class UserDataTaskListDeleteTaskRequest
  public sealed class UserDataTaskListDeleteTaskRequestEventArgs
  public sealed class UserDataTaskListSkipOccurrenceRequest
  public sealed class UserDataTaskListSkipOccurrenceRequestEventArgs
  public sealed class UserDataTaskListSyncManagerSyncRequest
  public sealed class UserDataTaskListSyncManagerSyncRequestEventArgs
}
namespace Windows.Gaming.Input {
  public sealed class FlightStick : IGameController
  public enum FlightStickButtons : uint
  public struct FlightStickReading
  public enum GameControllerSwitchKind
  public enum GameControllerSwitchPosition
  public sealed class RawGameController : IGameController
}
namespace Windows.Gaming.Input.Custom {
  public sealed class HidGameControllerProvider : IGameControllerProvider
  public interface IHidGameControllerInputSink : IGameControllerInputSink
}
namespace Windows.Graphics.Printing.PrintTicket {
  public interface IPrintTicketSchemaDisplayableElement : IPrintTicketSchemaElement
  public interface IPrintTicketSchemaElement
  public interface IPrintTicketSchemaOption : IPrintTicketSchemaDisplayableElement, IPrintTicketSchemaElement
  public interface IPrintTicketSchemaParameterDefinition : IPrintTicketSchemaElement
  public interface IPrintTicketSchemaValue
  public sealed class PrintTicketSchemaCapabilities : IPrintTicketSchemaElement
  public sealed class PrintTicketSchemaFeature : IPrintTicketSchemaDisplayableElement, IPrintTicketSchemaElement
  public sealed class PrintTicketSchemaParameterInitializer : IPrintTicketSchemaElement
  public enum tagSchemaParameterDataType
  public enum tagSchemaSelectionType
  public enum tagValueType
  public sealed class WorkflowPrintSchemaTicket : IPrintTicketSchemaElement
  public sealed class XmlNode
}
namespace Windows.Graphics.Printing.Workflow {
  public interface IPrinterPropertyBag
  public sealed class PrinterQueue
  public sealed class PrintTaskBackgroundSessionManager
  public sealed class PrintTaskConfig
  public sealed class PrintTaskForegroundSessionManager
  public sealed class PrintTaskSessionState
  public enum PrintTaskSessionStatus
  public sealed class PrintTaskSetupEventArgs
  public sealed class PrintTaskSubmissionController
  public sealed class PrintTaskSubmittedEventArgs
  public sealed class PrintTaskTarget
  public sealed class PrintTaskUIActivatedEventArgs : IActivatedEventArgs
  public sealed class PrintTaskXpsDataAvailableEventArgs
  public sealed class SourceContent
  public sealed class SpoolStreamContent
  public sealed class StreamTarget
  public sealed class WorkflowTaskContext
  public sealed class WorkflowTriggerDetails
  public sealed class XpsOmContent
  public sealed class XpsOmReceiver
}
namespace Windows.Management.Deployment {
  public enum DeploymentOptions : uint {
    EnableStreamedInstall = (uint)128,
    RequiredContentGroupOnly = (uint)256,
  }
  public sealed class PackageManager {
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RegisterPackageByFamilyNameAsync(string mainPackageFamilyName, IIterable<string> dependencyPackageFamilyNames, DeploymentOptions deploymentOptions, PackageVolume appDataVolume, IIterable<string> optionalPackageFamilyNames);
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
  }
}
namespace Windows.Management.Policies {
  public sealed class BinaryPolicy
  public sealed class BooleanPolicy
  public static class BrowserPolicies
  public sealed class BrowserPoliciesForUser
  public sealed class Int32Policy
  public sealed class StringPolicy
}
namespace Windows.Media {
  public sealed class MediaExtensionManager {
    void RegisterMediaExtensionForAppService(IMediaExtension extension, AppServiceConnection connection);
  }
  public sealed class MediaMarkerSpeechSentenceBoundary : IMediaMarker
  public sealed class MediaMarkerSpeechWordBoundary : IMediaMarker
  public static class MediaMarkerTypes {
    public static string SentenceBoundary { get; }
    public static string WordBoundary { get; }
  }
  public struct MediaTimeRange
}
namespace Windows.Media.Capture {
  public sealed class MediaCaptureInitializationSettings {
    bool AlwaysPlaySystemShutterSound { get; set; }
  }
}
namespace Windows.Media.Core {
  public sealed class ChapterCue : IMediaCue
  public sealed class DataCue : IMediaCue {
    PropertySet Properties { get; }
  }
  public sealed class ImageCue : IMediaCue
  public sealed class MediaBindingEventArgs {
    void SetAdaptiveMediaSource(AdaptiveMediaSource mediaSource);
    void SetStorageFile(IStorageFile file);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    AdaptiveMediaSource AdaptiveMediaSource { get; }
    MediaStreamSource MediaStreamSource { get; }
    MseStreamSource MseStreamSource { get; }
    Uri Uri { get; }
  }
  public sealed class MediaStreamSource : IMediaSource {
    IReference<double> MaxSupportedPlaybackRate { get; set; }
  }
  public enum TimedMetadataKind {
    ImageSubtitle = 6,
  }
  public enum TimedTextFontStyle
  public sealed class TimedTextSource {
    public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream);
    public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream, string defaultLanguage);
    public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri);
    public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri, string defaultLanguage);
  }
  public sealed class TimedTextStyle {
    TimedTextFontStyle FontStyle { get; set; }
    bool IsLineThroughEnabled { get; set; }
    bool IsOverlineEnabled { get; set; }
    bool IsUnderlineEnabled { get; set; }
  }
}
namespace Windows.Media.Core.Preview {
  public static class SoundLevelBroker
}
namespace Windows.Media.MediaProperties {
  public static class MediaEncodingSubtypes {
    public static string D16 { get; }
    public static string L16 { get; }
    public static string L8 { get; }
    public static string Vp9 { get; }
  }
  public enum SphericalVideoFrameFormat
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    SphericalVideoFrameFormat SphericalVideoFrameFormat { get; }
  }
}
namespace Windows.Media.Playback {
  public enum AutoLoadedDisplayPropertyKind
  public sealed class CurrentMediaPlaybackItemChangedEventArgs {
    MediaPlaybackItemChangedReason Reason { get; }
  }
  public sealed class MediaPlaybackItem : IMediaPlaybackSource {
    AutoLoadedDisplayPropertyKind AutoLoadedDisplayProperties { get; set; }
    bool IsDisabledInPlaybackList { get; set; }
    double TotalDownloadProgress { get; }
  }
  public enum MediaPlaybackItemChangedReason
  public sealed class MediaPlaybackList : IMediaPlaybackSource {
    IReference<uint> MaxPlayedItemsToKeepOpen { get; set; }
  }
  public sealed class MediaPlaybackSession {
    bool IsMirroring { get; set; }
    MediaPlaybackSphericalVideoProjection SphericalVideoProjection { get; }
    event TypedEventHandler<MediaPlaybackSession, object> BufferedRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> PlayedRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> SeekableRangesChanged;
    event TypedEventHandler<MediaPlaybackSession, object> SupportedPlaybackRatesChanged;
    IVectorView<MediaTimeRange> GetBufferedRanges();
    IVectorView<MediaTimeRange> GetPlayedRanges();
    IVectorView<MediaTimeRange> GetSeekableRanges();
    bool IsSupportedPlaybackRateRange(double rate1, double rate2);
  }
  public sealed class MediaPlaybackSphericalVideoProjection
}
namespace Windows.Media.Protection.PlayReady {
  public interface IPlayReadyLicenseSession2 : IPlayReadyLicenseSession
  public sealed class PlayReadyLicense : IPlayReadyLicense {
    bool ExpiresInRealTime { get; }
    bool InMemoryOnly { get; }
    Guid SecureStopId { get; }
    uint SecurityLevel { get; }
  }
  public sealed class PlayReadyLicenseAcquisitionServiceRequest : IMediaProtectionServiceRequest, IPlayReadyLicenseAcquisitionServiceRequest, IPlayReadyServiceRequest {
    PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
  }
  public sealed class PlayReadyLicenseSession : IPlayReadyLicenseSession, IPlayReadyLicenseSession2 {
    PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
  }
}
namespace Windows.Media.SpeechSynthesis {
  public sealed class SpeechSynthesisOptions
  public sealed class SpeechSynthesizer : IClosable {
    SpeechSynthesisOptions Options { get; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSource : IClosable, IMediaSource {
    IReference<TimeSpan> DesiredSeekableWindowSize { get; set; }
    AdaptiveMediaSourceDiagnostics Diagnostics { get; }
    IReference<TimeSpan> MaxSeekableWindowSize { get; }
    IReference<TimeSpan> MinLiveOffset { get; }
    void Close();
    AdaptiveMediaSourceCorrelatedTimes GetCorrelatedTimes();
  }
  public sealed class AdaptiveMediaSourceCorrelatedTimes
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs
  public sealed class AdaptiveMediaSourceDiagnostics
  public enum AdaptiveMediaSourceDiagnosticType
  public sealed class AdaptiveMediaSourceDownloadBitrateChangedEventArgs {
    AdaptiveMediaSourceDownloadBitrateChangedReason Reason { get; }
  }
  public enum AdaptiveMediaSourceDownloadBitrateChangedReason
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAccount {
    Uri AccountExperienceUrl { get; }
  }
  public sealed class MobileBroadbandDeviceInformation {
    string SimGid1 { get; }
    string SimPnn { get; }
    string SimSpn { get; }
  }
}
namespace Windows.Payments {
  public interface IPaymentItem
  public sealed class PaymentAddress
  public static class PaymentAppRegistration
  public sealed class PaymentCurrencyAmount
  public sealed class PaymentDetails
  public sealed class PaymentDetailsModifier
  public sealed class PaymentItem : IPaymentItem
  public static class PaymentMediator
  public sealed class PaymentMerchantInfo
  public sealed class PaymentMethodData
  public enum PaymentOptionPresence
  public sealed class PaymentOptions
  public sealed class PaymentRequest
  public sealed class PaymentRequestChangedEventArgs
  public delegate IAsyncOperation<PaymentRequestChangedEventResult> PaymentRequestChangedEventHandler(PaymentRequest paymentRequest, PaymentRequestChangedEventArgs args);
  public sealed class PaymentRequestChangedEventResult
  public enum PaymentRequestChangeSource
  public enum PaymentRequestCompletionStatus
  public enum PaymentRequestStatus
  public sealed class PaymentRequestSubmitResult
  public sealed class PaymentResponse
  public sealed class PaymentShippingOption : IPaymentItem
  public sealed class PaymentToken
  public sealed class PaymentTransaction
  public sealed class PaymentTransactionAcceptResult
}
namespace Windows.Perception.Spatial.Preview {
  public interface ISpatialAnchorStorage
  public sealed class SpatialAnchorMetadata
  public enum SpatialAnchorStorageContentChange
  public sealed class SpatialAnchorStorageContentChangedEventArgs
  public sealed class SpatialElement
  public sealed class SpatialElementChangedEventArgs
  public sealed class SpatialElementStore
}
namespace Windows.Perception.Spatial.Preview.Sharing {
  public interface ISpatialSharingSession
  public interface ISpatialSharingSessionHost
  public interface ISpatialSharingSessionManager
  public sealed class SessionChangedEventArgs
  public sealed class SessionInviteReceivedEventArgs
  public sealed class SessionMessageReceivedEventArgs
  public sealed class SessionParticipantEventArgs
  public sealed class SessionParticipantLeftEventArgs
  public sealed class SpatialSharingDevice
  public sealed class SpatialSharingQueryResult
  public sealed class SpatialSharingSession : ISpatialAnchorStorage, ISpatialSharingSession
  public sealed class SpatialSharingSessionHost : ISpatialSharingSessionHost
  public sealed class SpatialSharingSessionInvite
  public sealed class SpatialSharingSessionManager : ISpatialSharingSessionManager
  public sealed class SpatialSharingSessionParticipant
  public enum SpatialSharingSessionState
  public sealed class SpatialSharingSessionToken
}
namespace Windows.Security.Cryptography.Certificates {
  public sealed class CertificateExtension
  public sealed class CertificateRequestProperties {
    IVector<CertificateExtension> Extensions { get; }
    SubjectAlternativeNameInfo SubjectAlternativeName { get; }
    IVector<string> SuppressedDefaults { get; }
  }
  public sealed class SubjectAlternativeNameInfo {
    IVector<string> DistinguishedNames { get; }
    IVector<string> DnsNames { get; }
    IVector<string> EmailNames { get; }
    CertificateExtension Extension { get; }
    IVector<string> IPAddresses { get; }
    IVector<string> PrincipalNames { get; }
    IVector<string> Urls { get; }
  }
}
namespace Windows.Services.Cortana {
  public enum CortanaPermission
  public enum CortanaPermissionsChangeResult
  public sealed class CortanaPermissionsManager
}
namespace Windows.Services.Maps {
  public sealed class EnhancedWaypoint
  public static class MapRouteFinder {
    public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints);
    public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints, MapRouteDrivingOptions options);
  }
  public static class MapService {
    public static MapServiceDataUsagePreference DataUsagePreference { get; set; }
  }
  public enum MapServiceDataUsagePreference
  public enum WaypointKind
}
namespace Windows.Services.Maps.OfflineMaps {
  public sealed class OfflineMapPackage
  public sealed class OfflineMapPackageQueryResult
  public enum OfflineMapPackageQueryStatus
  public sealed class OfflineMapPackageStartDownloadResult
  public enum OfflineMapPackageStartDownloadStatus
  public enum OfflineMapPackageStatus
}
namespace Windows.System {
  public sealed class DispatcherQueue
  public delegate void DispatcherQueueHandler();
  public delegate IAsyncAction DispatcherQueueHandlerAsync();
  public sealed class DispatcherQueueOptions
  public enum DispatcherQueuePriority
  public sealed class DispatcherQueueTimer
}
namespace Windows.System.Preview.RemoteSessions {
  public enum BinaryChannelTransportMode
  public sealed class RemoteSession
  public sealed class RemoteSessionAddedEventArgs
  public sealed class RemoteSessionBinaryChannel
  public sealed class RemoteSessionBinaryMessageReceivedEventArgs
  public enum RemoteSessionConnectionStatus
  public sealed class RemoteSessionConnectResult
  public sealed class RemoteSessionDisconnectedEventArgs
  public enum RemoteSessionDisconnectedReason
  public sealed class RemoteSessionInfo
  public sealed class RemoteSessionInvitationManager
  public sealed class RemoteSessionInvitationReceivedEventArgs
  public sealed class RemoteSessionJoinRequest
  public sealed class RemoteSessionJoinRequestedEventArgs
  public sealed class RemoteSessionParticipant
  public sealed class RemoteSessionParticipantChangedEventArgs
  public sealed class RemoteSessionRemovedEventArgs
  public sealed class RemoteSessionUpdatedEventArgs
  public sealed class RemoteSessionWatcher
}
namespace Windows.System.Profile {
  public static class EducationSettings
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    IAsyncOperation<bool> GetResourceAvailableAsync(string query);
  }
}
namespace Windows.System.RemoteSystems.Preview {
  public static class RemoteSystemResourceQuery
}
namespace Windows.UI.Composition {
  public class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
  }
  public sealed class CompositionGraphicsDevice : CompositionObject {
    CompositionVirtualDrawingSurface CreateVirtualDrawingSurface(Size sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
  }
  public sealed class CompositionVirtualDrawingSurface : CompositionDrawingSurface, ICompositionSurface
  public sealed class CompositionVisualSurface : CompositionObject, ICompositionSurface
  public sealed class CompositionWindowBackdropBrush : CompositionBrush
  public sealed class Compositor : IClosable {
    CompositionVisualSurface CreateVisualSurface();
    CompositionWindowBackdropBrush CreateWindowBackdropBrush();
  }
  public sealed class LayerVisual : ContainerVisual {
    CompositionShadow Shadow { get; set; }
  }
  public class Visual : CompositionObject {
    Vector3 RelativeOffset { get; set; }
    Vector2 RelativeSize { get; set; }
    Visual TransformParent { get; set; }
  }
}
namespace Windows.UI.Core {
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    event TypedEventHandler<CoreWindow, object> ResizeCompleted;
    event TypedEventHandler<CoreWindow, object> ResizeStarted;
  }
}
namespace Windows.UI.Input {
  public static class KnownSimpleHapticsControllerWaveforms
  public sealed class RadialController {
    event TypedEventHandler<RadialController, RadialControllerButtonHoldingEventArgs> ButtonHolding;
    event TypedEventHandler<RadialController, RadialControllerButtonPressedEventArgs> ButtonPressed;
    event TypedEventHandler<RadialController, RadialControllerButtonReleasedEventArgs> ButtonReleased;
  }
  public sealed class RadialControllerButtonClickedEventArgs {
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerButtonHoldingEventArgs
  public sealed class RadialControllerButtonPressedEventArgs
  public sealed class RadialControllerButtonReleasedEventArgs
  public sealed class RadialControllerConfiguration {
    RadialController ActiveControllerWhenMenuIsSuppressed { get; set; }
    bool IsMenuSuppressed { get; set; }
  }
  public sealed class RadialControllerControlAcquiredEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerMenuItem {
    public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily);
    public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily, Uri fontUri);
  }
  public sealed class RadialControllerRotationChangedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerScreenContactContinuedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class RadialControllerScreenContactEndedEventArgs
  public sealed class RadialControllerScreenContactStartedEventArgs {
    bool IsButtonPressed { get; }
    SimpleHapticsController SimpleHapticsController { get; }
  }
  public sealed class SimpleHapticsController
  public sealed class SimpleHapticsControllerFeedback
}
namespace Windows.UI.Input.Core {
  public sealed class RadialControllerIndependentInputSource
}
namespace Windows.UI.Input.Inking {
  public enum InkPersistenceFormat
  public sealed class InkPresenterProtractor : IInkPresenterStencil
  public sealed class InkPresenterRuler : IInkPresenterStencil {
    bool AreTickMarksVisible { get; set; }
    bool IsCompassVisible { get; set; }
  }
  public enum InkPresenterStencilKind {
    Protractor = 2,
  }
  public sealed class InkStroke {
    uint Id { get; }
    IReference<TimeSpan> StrokeDuration { get; set; }
    IReference<DateTime> StrokeStartedTime { get; set; }
  }
  public sealed class InkStrokeBuilder {
    InkStroke CreateStrokeFromInkPoints(IIterable<InkPoint> inkPoints, Matrix3x2 transform, IReference<DateTime> strokeStartedTime, IReference<TimeSpan> strokeDuration);
  }
  public sealed class InkStrokeContainer : IInkStrokeContainer {
    InkStroke GetStrokeById(uint id);
    IAsyncOperationWithProgress<uint, uint> SaveAsync(IOutputStream outputStream, InkPersistenceFormat inkPersistenceFormat);
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialHoldCompletedEventArgs {
    SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
  }
  public sealed class SpatialHoldStartedEventArgs {
    SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
  }
  public sealed class SpatialInteractionDetectedEventArgs {
    SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
  }
  public enum SpatialInteractionKind
  public sealed class SpatialInteractionSource {
    bool SupportsPointing { get; }
  }
  public sealed class SpatialInteractionSourceEventArgs {
    SpatialInteractionKind InteractionKind { get; }
    SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
  }
  public sealed class SpatialInteractionSourceState {
    bool IsGrasped { get; }
    bool IsPrimaryPressed { get; }
    bool IsSecondaryPressed { get; }
    SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
  }
  public sealed class SpatialPointerPose {
    SpatialPointingPose TryGetPointingPose(SpatialInteractionSource source);
  }
  public sealed class SpatialPointingPose
  public sealed class SpatialTappedEventArgs {
    SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
  }
}
namespace Windows.UI.Notifications {
  public sealed class NotificationData
  public enum NotificationUpdateResult
  public sealed class ToastCollection
  public sealed class ToastCollectionManager
  public sealed class ToastNotification {
    NotificationData Data { get; set; }
  }
  public sealed class ToastNotificationHistoryChangedTriggerDetail {
    string CollectionId { get; }
  }
  public static class ToastNotificationManager {
    public static ToastNotificationManagerForUser Current { get; }
  }
  public sealed class ToastNotificationManagerForUser {
    IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionIdAsync(string collectionId);
    ToastCollectionManager GetToastCollectionManager();
    ToastCollectionManager GetToastCollectionManager(string appId);
    IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionIdAsync(string collectionId);
  }
  public sealed class ToastNotifier {
    NotificationUpdateResult Update(NotificationData data, string tag);
    NotificationUpdateResult Update(NotificationData data, string tag, string group);
  }
}
namespace Windows.UI.Text {
  public enum TextDecorations : uint
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationView {
    IAsyncOperation<bool> TryConsolidateAsync();
  }
  public sealed class ApplicationViewConsolidatedEventArgs {
    bool IsAppInitiated { get; }
  }
}
namespace Windows.UI.WebUI {
  public sealed class WebUIContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
  public sealed class WebUILockScreenComponentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral
}
namespace Windows.UI.Xaml {
  public sealed class BringIntoViewOptions
  public class FrameworkElement : UIElement {
    public static void DeferTree(DependencyObject element);
  }
  public class UIElement : DependencyObject {
    double KeyTipHorizontalOffset { get; set; }
    public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
    KeyTipPlacementMode KeyTipPlacementMode { get; set; }
    public static DependencyProperty KeyTipPlacementModeProperty { get; }
    double KeyTipVerticalOffset { get; set; }
    public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
    XYFocusKeyboardNavigationMode XYFocusKeyboardNavigation { get; set; }
    public static DependencyProperty XYFocusKeyboardNavigationProperty { get; }
    void StartBringIntoView();
    void StartBringIntoView(BringIntoViewOptions options);
  }
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty CultureProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty CultureProperty { get; }
    public static int GetCulture(DependencyObject element);
    public static void SetCulture(DependencyObject element, int value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public class AutomationPeer : DependencyObject {
    int GetCulture();
    virtual int GetCultureCore();
  }
  public sealed class MapControlAutomationPeer : FrameworkElementAutomationPeer, IScrollProvider, ITransformProvider, ITransformProvider2 {
    bool CanMove { get; }
    bool CanResize { get; }
    bool CanRotate { get; }
    bool CanZoom { get; }
    double MaxZoom { get; }
    double MinZoom { get; }
    double ZoomLevel { get; }
    void Move(double x, double y);
    void Resize(double width, double height);
    void Rotate(double degrees);
    void Zoom(double zoom);
    void ZoomByUnit(ZoomUnit zoomUnit);
  }
}
namespace Windows.UI.Xaml.Controls {
  public class ContentDialog : ContentControl {
    bool IsTertiaryButtonEnabled { get; set; }
    public static DependencyProperty IsTertiaryButtonEnabledProperty { get; }
    Style PrimaryButtonStyle { get; set; }
    public static DependencyProperty PrimaryButtonStyleProperty { get; }
    Style SecondaryButtonStyle { get; set; }
    public static DependencyProperty SecondaryButtonStyleProperty { get; }
    ICommand TertiaryButtonCommand { get; set; }
    object TertiaryButtonCommandParameter { get; set; }
    public static DependencyProperty TertiaryButtonCommandParameterProperty { get; }
    public static DependencyProperty TertiaryButtonCommandProperty { get; }
    Style TertiaryButtonStyle { get; set; }
    public static DependencyProperty TertiaryButtonStyleProperty { get; }
    string TertiaryButtonText { get; set; }
    public static DependencyProperty TertiaryButtonTextProperty { get; }
    event TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> TertiaryButtonClick;
  }
  public enum ContentDialogResult {
    Tertiary = 3,
  }
  public class Control : FrameworkElement {
    Uri DefaultStyleResourceUri { get; set; }
    public static DependencyProperty DefaultStyleResourceUriProperty { get; }
  }
  public sealed class FocusEngagedEventArgs : RoutedEventArgs {
    bool Handled { get; set; }
  }
  public class Frame : ContentControl, INavigate {
    void SetNavigationState(string navigationState, bool suppressNavigate);
  }
  public class InkToolbar : Control {
    InkToolbarButtonFlyoutPlacement ButtonFlyoutPlacement { get; set; }
    public static DependencyProperty ButtonFlyoutPlacementProperty { get; }
    bool IsStencilButtonChecked { get; set; }
    public static DependencyProperty IsStencilButtonCheckedProperty { get; }
    Orientation Orientation { get; set; }
    public static DependencyProperty OrientationProperty { get; }
    event TypedEventHandler<InkToolbar, object> BringStencilIntoViewRequested;
    event TypedEventHandler<InkToolbar, object> EraserWidthChanged;
    event TypedEventHandler<InkToolbar, InkToolbarIsStencilButtonCheckedChangedEventArgs> IsStencilButtonCheckedChanged;
    InkToolbarMenuButton GetMenuButton(InkToolbarMenuKind menu);
  }
  public enum InkToolbarButtonFlyoutPlacement
  public class InkToolbarEraserButton : InkToolbarToolButton {
    InkToolbarEraserKind EraserKind { get; set; }
    public static DependencyProperty EraserKindProperty { get; }
    bool IsClearAllVisible { get; set; }
    public static DependencyProperty IsClearAllVisibleProperty { get; }
    bool IsWidthSliderVisible { get; set; }
    public static DependencyProperty IsWidthSliderVisibleProperty { get; }
    double MaxStrokeWidth { get; set; }
    public static DependencyProperty MaxStrokeWidthProperty { get; }
    double MinStrokeWidth { get; set; }
    public static DependencyProperty MinStrokeWidthProperty { get; }
    double SelectedStrokeWidth { get; set; }
    public static DependencyProperty SelectedStrokeWidthProperty { get; }
  }
  public enum InkToolbarEraserKind
  public class InkToolbarFlyoutItem : ButtonBase
  public enum InkToolbarFlyoutItemKind
  public sealed class InkToolbarIsStencilButtonCheckedChangedEventArgs
  public class InkToolbarMenuButton : ToggleButton
  public enum InkToolbarMenuKind
  public class InkToolbarPenConfigurationControl : Control {
    InkToolbarEraserButton EraserButton { get; }
    public static DependencyProperty EraserButtonProperty { get; }
  }
  public class InkToolbarStencilButton : InkToolbarMenuButton
  public enum InkToolbarStencilKind
  public sealed class RichTextBlock : FrameworkElement {
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
  }
  public sealed class TextBlock : FrameworkElement {
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapBillboard : MapElement
  public sealed class MapContextRequestedEventArgs
  public sealed class MapControl : Control {
    MapProjection MapProjection { get; set; }
    public static DependencyProperty MapProjectionProperty { get; }
    MapStyleSheet StyleSheet { get; set; }
    public static DependencyProperty StyleSheetProperty { get; }
    Thickness ViewPadding { get; set; }
    public static DependencyProperty ViewPaddingProperty { get; }
    event TypedEventHandler<MapControl, MapContextRequestedEventArgs> MapContextRequested;
    IVectorView<MapElement> FindMapElementsAtOffset(Point offset, double radius);
    void GetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
    void StartContinuousPan(double horizontalPixelsPerSecond, double verticalPixelsPerSecond);
    void StopContinuousPan();
    IAsyncOperation<bool> TryPanAsync(double horizontalPixels, double verticalPixels);
    IAsyncOperation<bool> TryPanToAsync(Geopoint location);
  }
  public enum MapProjection
  public enum MapStyle {
    Custom = 7,
  }
  public sealed class MapStyleSheet : DependencyObject
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class FlyoutBase : DependencyObject {
    DependencyObject OverlayInputPassThroughElement { get; set; }
    public static DependencyProperty OverlayInputPassThroughElementProperty { get; }
  }
}
namespace Windows.UI.Xaml.Documents {
  public sealed class Hyperlink : Span {
    FocusState FocusState { get; }
    public static DependencyProperty FocusStateProperty { get; }
    event RoutedEventHandler GotFocus;
    event RoutedEventHandler LostFocus;
    bool Focus(FocusState value);
  }
  public class TextElement : DependencyObject {
    double KeyTipHorizontalOffset { get; set; }
    public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
    KeyTipPlacementMode KeyTipPlacementMode { get; set; }
    public static DependencyProperty KeyTipPlacementModeProperty { get; }
    double KeyTipVerticalOffset { get; set; }
    public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
    TextDecorations TextDecorations { get; set; }
    public static DependencyProperty TextDecorationsProperty { get; }
    event TypedEventHandler<TextElement, AccessKeyDisplayDismissedEventArgs> AccessKeyDisplayDismissed;
    event TypedEventHandler<TextElement, AccessKeyDisplayRequestedEventArgs> AccessKeyDisplayRequested;
    event TypedEventHandler<TextElement, AccessKeyInvokedEventArgs> AccessKeyInvoked;
  }
}
namespace Windows.UI.Xaml.Input {
  public sealed class AccessKeyManager {
    public static bool AreKeyTipsEnabled { get; set; }
  }
  public enum KeyTipPlacementMode
  public enum XYFocusKeyboardNavigationMode
}
namespace Windows.UI.Xaml.Markup {
  public sealed class XamlMarkupHelper
}
 
namespace Windows.Media.Capture {
  public sealed class AppCaptureDurationGeneratedEventArgs
  public sealed class AppCaptureFileGeneratedEventArgs
  public enum AppCaptureMicrophoneCaptureState
  public sealed class AppCaptureMicrophoneCaptureStateChangedEventArgs
  public enum AppCaptureRecordingState
  public sealed class AppCaptureRecordingStateChangedEventArgs
  public sealed class AppCaptureRecordOperation
  public sealed class AppCaptureServices
  public sealed class AppCaptureState
}
 
namespace Windows.Services.Store {
  public sealed class StoreContext {
    IAsyncOperation<StoreProductResult> FindStoreProductForPackageAsync(IIterable<string> productKinds, Package package);
  }
}

API Removals

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

API Additions not yet implemented

The Bluetooth APIs were included to receive feedback from the Developer community.

namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter
  public sealed class BluetoothDeviceId
  public enum BluetoothError {
    TransportNotSupported = 9,
  }
  public sealed class BluetoothLEDevice : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync();
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(GattUuid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
  }
  public enum BluetoothTransportOptions : uint
}
namespace Windows.Devices.Bluetooth.Background {
  public enum BluetoothEventTriggeringMode
  public sealed class GattCharacteristicNotificationTriggerDetails {
    BluetoothError Error { get; }
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
    IVectorView<GattValueChangedEventArgs> ValueChangedEvents { get; }
  }
  public sealed class GattServiceProviderBackgroundInfo
  public sealed class GattServiceProviderRequestActivityInfo
  public enum GattServiceProviderRequestActivityType
  public enum GattServiceProviderRequestAttributeType
  public sealed class GattServiceProviderTriggerDetails
  public enum GattServiceProviderTriggerReason
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattCharacteristic {
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync();
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(GattUuid descriptorUuid);
    IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(GattUuid descriptorUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value, GattWriteOption writeOption);
  }
  public sealed class GattCharacteristicsResult
  public sealed class GattClientNotificationResult
  public enum GattCommunicationStatus {
    ProtocolError = 2,
  }
  public sealed class GattDescriptor {
    IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
  }
  public sealed class GattDescriptorsResult
  public sealed class GattDeviceService : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    GattSession Session { get; }
    public static IAsyncOperation<GattDeviceService> FromIdAsync(string deviceId, GattSharingMode sharingMode);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync();
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(GattUuid characteristicUuid);
    IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(GattUuid characteristicUuid, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelector(GattUuid gattUuid);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync();
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(GattUuid serviceUuid);
    IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation<DeviceAccessStatus> RequestAccessAsync(GattSharingMode sharingMode);
  }
  public sealed class GattDeviceServicesResult
  public sealed class GattLocalCharacteristic
  public sealed class GattLocalCharacteristicParameters
  public sealed class GattLocalDescriptor
  public sealed class GattLocalDescriptorParameters
  public sealed class GattPresentationFormat {
    public static GattPresentationFormat FromParts(byte formatType, int exponent, ushort unit, byte namespaceId, ushort description);
  }
  public static class GattProtocolError
  public sealed class GattPublishedService
  public sealed class GattReadClientCharacteristicConfigurationDescriptorResult {
    IReference<byte> ProtocolError { get; }
  }
  public sealed class GattReadRequest
  public sealed class GattReadRequestedEventArgs
  public sealed class GattReadResponse
  public sealed class GattReadResult {
    IReference<byte> ProtocolError { get; }
  }
  public sealed class GattReliableWriteTransaction {
    IAsyncOperation<GattWriteResult> CommitWithResultAsync();
  }
  public sealed class GattServiceProvider
  public sealed class GattServiceProviderAdvertisingParameters
  public sealed class GattServiceProviderResult
  public enum GattServiceProviderStatus
  public sealed class GattServiceProviderStatusChangedEventArgs
  public enum GattServiceType
  public sealed class GattSession : IClosable
  public enum GattSessionStatus
  public sealed class GattSessionStatusChangedEventArgs
  public enum GattSharingMode
  public sealed class GattSubscribedClient
  public sealed class GattUuid
  public sealed class GattWriteRequest
  public sealed class GattWriteRequestedEventArgs
  public sealed class GattWriteResponse
  public sealed class GattWriteResult
}
namespace Windows.Devices.Bluetooth.Rfcomm {
  public sealed class RfcommDeviceService : IClosable {
    public static IAsyncOperation<RfcommDeviceServicesResult> FromIdWithResultAsync(string deviceId);
  }
  public sealed class RfcommServiceProvider {
    public static IAsyncOperation<RfcommServiceProviderResult> CreateWithResultAsync(RfcommServiceId serviceId);
  }
  public sealed class RfcommServiceProviderResult
}
 

Join the conversation