November 21, 2016 8:00 am

Windows 10 SDK Preview Build 14965 Released

By / Senior Technical Product Manager, Windows Developer Team

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:
      [code lang=”xml”]<PropertyGroup><DoBundleInstallationChecks>false</DoBundleInstallationChecks></PropertyGroup>[/code]
  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.

[code lang=”csharp”]
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);
}
}
[/code]

API Removals

[code lang=”csharp”]
namespace Windows.UI.Composition {
public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
}
}
[/code]

API Additions not yet implemented

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

[code lang=”csharp”]
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
}
 
[/code]