



ActivationKind 

Print3DWorkflow : 1011,


DevicePairing : 1013,

DevicePairingActivatedEventArgs 

DeviceInformation { get; } : DeviceInformation


Kind { get; } : ActivationKind


PreviousExecutionState { get; } : ApplicationExecutionState


SplashScreen { get; } : SplashScreen

IDevicePairingActivatedEventArgs 

DeviceInformation { get; } : DeviceInformation


AppointmentCalendarSyncStatus 

ManualAccountRemovalRequired : 6,


PhoneTrigger 

ctor(PhoneTriggerType type, Boolean oneShot)


OneShot { get; } : Boolean


TriggerType { get; } : PhoneTriggerType

SensorDataThresholdTrigger 

ctor(ISensorDataThreshold threshold)




CallsBackgroundContract

PhoneCallBlockedReason 

InCallBlockingList : 0,


PrivateNumber : 1,


UnknownNumber : 2,

PhoneCallBlockedTriggerDetails 

CallBlockedReason { get; } : PhoneCallBlockedReason


LineId { get; } : Guid


PhoneNumber { get; } : String

PhoneCallOriginDataRequestTriggerDetails 

PhoneNumber { get; } : String


RequestId { get; } : Guid

PhoneLineChangedTriggerDetails 

HasLinePropertyChanged(PhoneLineProperties lineProperty) : Boolean


ChangeType { get; } : PhoneLineChangeKind


LineId { get; } : Guid

PhoneLineChangeKind 

Added : 0,


Removed : 1,


PropertiesChanged : 2,

PhoneLineProperties 

None : 0,


BrandingOptions : 1,


CanDial : 2,


CellularDetails : 4,


DisplayColor : 8,


DisplayName : 16,


NetworkName : 32,


NetworkState : 64,


Transport : 128,


Voicemail : 256,

PhoneNewVoicemailMessageTriggerDetails 

LineId { get; } : Guid


OperatorMessage { get; } : String


VoicemailCount { get; } : Int32

PhoneTriggerType 

NewVoicemailMessage : 0,


CallHistoryChanged : 1,


LineChanged : 2,


AirplaneModeDisabledForEmergencyCall : 3,


CallOriginDataRequest : 4,


CallBlocked : 5,

CallAnswerEventArgs 

AcceptedMedia { get; } : VoipPhoneCallMedia

CallRejectEventArgs 

RejectReason { get; } : VoipPhoneCallRejectReason

CallStateChangeEventArgs 

State { get; } : VoipPhoneCallState


CallsVoipContract

MuteChangeEventArgs 

Muted { get; } : Boolean

VoipCallCoordinator 

CancelUpgrade(Guid callUpgradeGuid) : Void


GetDefault() static : VoipCallCoordinator


MuteStateChanged event : TypedEventHandler<VoipCallCoordinator,MuteChangeEventArgs>


NotifyMuted() : Void


NotifyUnmuted() : Void


RequestIncomingUpgradeToVideoCall(String context, String contactName, String contactNumber, Uri contactImage, String serviceName, Uri brandingImage, String callDetails, Uri ringtone, TimeSpan ringTimeout) : VoipPhoneCall


RequestNewIncomingCall(String context, String contactName, String contactNumber, Uri contactImage, String serviceName, Uri brandingImage, String callDetails, Uri ringtone, VoipPhoneCallMedia media, TimeSpan ringTimeout) : VoipPhoneCall


RequestNewOutgoingCall(String context, String contactName, String serviceName, VoipPhoneCallMedia media) : VoipPhoneCall


RequestOutgoingUpgradeToVideoCall(Guid callUpgradeGuid, String context, String contactName, String serviceName) : VoipPhoneCall


ReserveCallResourcesAsync(String taskEntryPoint) : IAsyncOperation<VoipPhoneCallResourceReservationStatus>


TerminateCellularCall(Guid callUpgradeGuid) : Void

VoipPhoneCall 

AnswerRequested event : TypedEventHandler<VoipPhoneCall,CallAnswerEventArgs>


CallMedia { get; set; } : VoipPhoneCallMedia


ContactName { get; set; } : String


EndRequested event : TypedEventHandler<VoipPhoneCall,CallStateChangeEventArgs>


HoldRequested event : TypedEventHandler<VoipPhoneCall,CallStateChangeEventArgs>


NotifyCallActive() : Void


NotifyCallEnded() : Void


NotifyCallHeld() : Void


NotifyCallReady() : Void


RejectRequested event : TypedEventHandler<VoipPhoneCall,CallRejectEventArgs>


ResumeRequested event : TypedEventHandler<VoipPhoneCall,CallStateChangeEventArgs>


StartTime { get; set; } : DateTimeOffset

VoipPhoneCallMedia 

None : 0,


Audio : 1,


Video : 2,

VoipPhoneCallRejectReason 

UserIgnored : 0,


TimedOut : 1,


OtherIncomingCall : 2,


EmergencyCallExists : 3,


InvalidCallState : 4,

VoipPhoneCallResourceReservationStatus 

Success : 0,


ResourcesNotAvailable : 1,

VoipPhoneCallState 

Ended : 0,


Held : 1,


Active : 2,


Incoming : 3,


Outgoing : 4,


ContactCardOptions 

ServerSearchContactListIds { get; } : IList<String>

ContactListSyncStatus 

ManualAccountRemovalRequired : 6,




CoreDragInfo 

AllowedOperations { get; } : DataPackageOperation

CoreDragOperation 

AllowedOperations { get; set; } : DataPackageOperation

DataPackageView 

SetAcceptedFormatId(String formatId) : Void

OperationCompletedEventArgs 

AcceptedFormatId { get; } : String


EmailCertificateValidationStatus 

Success : 0,


NoMatch : 1,


InvalidUsage : 2,


InvalidCertificate : 3,


Revoked : 4,


ChainRevoked : 5,


RevocationServerFailure : 6,


Expired : 7,


Untrusted : 8,


ServerError : 9,


UnknownFailure : 10,

EmailMailbox 

ResolveRecipientsAsync(IEnumerable<String> recipients) : IAsyncOperation<IReadOnlyList<EmailRecipientResolutionResult>>


TryCreateFolderAsync(String parentFolderId, String name) : IAsyncOperation<EmailMailboxCreateFolderResult>


TryDeleteFolderAsync(String folderId) : IAsyncOperation<EmailMailboxDeleteFolderStatus>


TryEmptyFolderAsync(String folderId) : IAsyncOperation<EmailMailboxEmptyFolderStatus>


ValidateCertificatesAsync(IEnumerable<Certificate> certificates) : IAsyncOperation<IReadOnlyList<EmailCertificateValidationStatus>>

EmailMailboxCapabilities 

CanCreateFolder { get; } : Boolean


CanDeleteFolder { get; } : Boolean


CanEmptyFolder { get; } : Boolean


CanMoveFolder { get; } : Boolean


CanResolveRecipients { get; } : Boolean


CanValidateCertificates { get; } : Boolean

EmailMailboxCreateFolderResult 

Folder { get; } : EmailFolder


Status { get; } : EmailMailboxCreateFolderStatus

EmailMailboxCreateFolderStatus 

Success : 0,


NetworkError : 1,


PermissionsError : 2,


ServerError : 3,


UnknownFailure : 4,


NameCollision : 5,


ServerRejected : 6,

EmailMailboxDeleteFolderStatus 

Success : 0,


NetworkError : 1,


PermissionsError : 2,


ServerError : 3,


UnknownFailure : 4,


CouldNotDeleteEverything : 5,

EmailMailboxEmptyFolderStatus 

Success : 0,


NetworkError : 1,


PermissionsError : 2,


ServerError : 3,


UnknownFailure : 4,


CouldNotDeleteEverything : 5,

EmailMailboxPolicies 

MustEncryptSmimeMessages { get; } : Boolean


MustSignSmimeMessages { get; } : Boolean

EmailMailboxSyncStatus 

ManualAccountRemovalRequired : 6,

EmailMeetingInfo 

IsReportedOutOfDateByServer { get; } : Boolean

EmailMessage 

SmimeData { get; set; } : IRandomAccessStreamReference


SmimeKind { get; set; } : EmailMessageSmimeKind

EmailMessageSmimeKind 

None : 0,


ClearSigned : 1,


OpaqueSigned : 2,


Encrypted : 3,

EmailRecipientResolutionResult 

PublicKeys { get; } : IReadOnlyList<Certificate>


Status { get; } : EmailRecipientResolutionStatus

EmailRecipientResolutionStatus 

Success : 0,


RecipientNotFound : 1,


AmbiguousRecipient : 2,


NoCertificate : 3,


CertificateRequestLimitReached : 4,


CannotResolveDistributionList : 5,


ServerError : 6,


UnknownFailure : 7,


ChatConversation 

CanModifyParticipants { get; set; } : Boolean




AppInstallItem 

Cancel(String correlationVector) : Void


Pause(String correlationVector) : Void


Restart(String correlationVector) : Void

AppInstallManager 

Cancel(String productId, String correlationVector) : Void


GetIsAppAllowedToInstallAsync(String productId, String skuId, String catalogId, String correlationVector) : IAsyncOperation<Boolean>


Pause(String productId, String correlationVector) : Void


Restart(String productId, String correlationVector) : Void


SearchForAllUpdatesAsync(String correlationVector) : IAsyncOperation<IReadOnlyList<AppInstallItem>>


SearchForUpdatesAsync(String productId, String skuId, String catalogId, String correlationVector) : IAsyncOperation<AppInstallItem>


StartAppInstallAsync(String productId, String skuId, Boolean repair, Boolean forceUseOfNonRemovableStorage, String catalogId, String bundleId, String correlationVector) : IAsyncOperation<AppInstallItem>


UpdateAppByPackageFamilyNameAsync(String packageFamilyName, String correlationVector) : IAsyncOperation<AppInstallItem>

StoreConfiguration 

PurchasePromptingPolicy static { get; set; } : Nullable<UInt32>

CurrentApp 

GetCustomerCollectionsIdAsync(String serviceTicket, String publisherUserId) static : IAsyncOperation<String>


GetCustomerPurchaseIdAsync(String serviceTicket, String publisherUserId) static : IAsyncOperation<String>

ListingInformation 

CurrencyCode { get; } : String


FormattedBasePrice { get; } : String


IsOnSale { get; } : Boolean


SaleEndDate { get; } : DateTimeOffset

ProductListing 

CurrencyCode { get; } : String


FormattedBasePrice { get; } : String


IsOnSale { get; } : Boolean


SaleEndDate { get; } : DateTimeOffset


UserDataAccount 

EnterpriseId { get; } : String


IsProtectedUnderLock { get; } : Boolean



JsonError 

GetStatus(Int32 hresult) static : JsonErrorStatus



AdcController 

GetDefaultAsync() static : IAsyncOperation<AdcController>



RfcommServiceProvider 

StartAdvertising(StreamSocketListener listener, Boolean radioDiscoverable) : Void

BluetoothAddressType 

Public : 0,


Random : 1,

BluetoothDevice 

DeviceInformation { get; } : DeviceInformation


GetDeviceSelectorFromBluetoothAddress(UInt64 bluetoothAddress) static : String


GetDeviceSelectorFromClassOfDevice(BluetoothClassOfDevice classOfDevice) static : String


GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus connectionStatus) static : String


GetDeviceSelectorFromDeviceName(String deviceName) static : String


GetDeviceSelectorFromPairingState(Boolean pairingState) static : String

BluetoothError 

DisabledByUser : 7,

BluetoothLEAppearance 

Category { get; } : UInt16


FromParts(UInt16 appearanceCategory, UInt16 appearanceSubCategory) static : BluetoothLEAppearance


FromRawValue(UInt16 rawValue) static : BluetoothLEAppearance


RawValue { get; } : UInt16


SubCategory { get; } : UInt16

BluetoothLEAppearanceCategories 

BarcodeScanner static { get; } : UInt16


BloodPressure static { get; } : UInt16


Clock static { get; } : UInt16


Computer static { get; } : UInt16


Cycling static { get; } : UInt16


Display static { get; } : UInt16


EyeGlasses static { get; } : UInt16


GlucoseMeter static { get; } : UInt16


HeartRate static { get; } : UInt16


HumanInterfaceDevice static { get; } : UInt16


Keyring static { get; } : UInt16


MediaPlayer static { get; } : UInt16


OutdoorSportActivity static { get; } : UInt16


Phone static { get; } : UInt16


PulseOximeter static { get; } : UInt16


RemoteControl static { get; } : UInt16


RunningWalking static { get; } : UInt16


Tag static { get; } : UInt16


Thermometer static { get; } : UInt16


Uncategorized static { get; } : UInt16


Watch static { get; } : UInt16


WeightScale static { get; } : UInt16

BluetoothLEAppearanceSubcategories 

BarcodeScanner static { get; } : UInt16


BloodPressureArm static { get; } : UInt16


BloodPressureWrist static { get; } : UInt16


CardReader static { get; } : UInt16


CyclingCadenceSensor static { get; } : UInt16


CyclingComputer static { get; } : UInt16


CyclingPowerSensor static { get; } : UInt16


CyclingSpeedCadenceSensor static { get; } : UInt16


CyclingSpeedSensor static { get; } : UInt16


DigitalPen static { get; } : UInt16


DigitizerTablet static { get; } : UInt16


Gamepad static { get; } : UInt16


Generic static { get; } : UInt16


HeartRateBelt static { get; } : UInt16


Joystick static { get; } : UInt16


Keyboard static { get; } : UInt16


LocationDisplay static { get; } : UInt16


LocationNavigationDisplay static { get; } : UInt16


LocationNavigationPod static { get; } : UInt16


LocationPod static { get; } : UInt16


Mouse static { get; } : UInt16


OximeterFingertip static { get; } : UInt16


OximeterWristWorn static { get; } : UInt16


RunningWalkingInShoe static { get; } : UInt16


RunningWalkingOnHip static { get; } : UInt16


RunningWalkingOnShoe static { get; } : UInt16


SportsWatch static { get; } : UInt16


ThermometerEar static { get; } : UInt16

BluetoothLEDevice 

Appearance { get; } : BluetoothLEAppearance


BluetoothAddressType { get; } : BluetoothAddressType


DeviceInformation { get; } : DeviceInformation


FromBluetoothAddressAsync(UInt64 bluetoothAddress, BluetoothAddressType bluetoothAddressType) static : IAsyncOperation<BluetoothLEDevice>


GetDeviceSelectorFromAppearance(BluetoothLEAppearance appearance) static : String


GetDeviceSelectorFromBluetoothAddress(UInt64 bluetoothAddress) static : String


GetDeviceSelectorFromBluetoothAddress(UInt64 bluetoothAddress, BluetoothAddressType bluetoothAddressType) static : String


GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus connectionStatus) static : String


GetDeviceSelectorFromDeviceName(String deviceName) static : String


GetDeviceSelectorFromPairingState(Boolean pairingState) static : String


DeviceInformationCustomPairing 

PairAsync(DevicePairingKinds pairingKindsSupported) : IAsyncOperation<DevicePairingResult>


PairAsync(DevicePairingKinds pairingKindsSupported, DevicePairingProtectionLevel minProtectionLevel) : IAsyncOperation<DevicePairingResult>


PairAsync(DevicePairingKinds pairingKindsSupported, DevicePairingProtectionLevel minProtectionLevel, IDevicePairingSettings devicePairingSettings) : IAsyncOperation<DevicePairingResult>


PairingRequested event : TypedEventHandler<DeviceInformationCustomPairing,DevicePairingRequestedEventArgs>

DeviceInformationPairing 

Custom { get; } : DeviceInformationCustomPairing


PairAsync(DevicePairingProtectionLevel minProtectionLevel, IDevicePairingSettings devicePairingSettings) : IAsyncOperation<DevicePairingResult>


ProtectionLevel { get; } : DevicePairingProtectionLevel


TryRegisterForAllInboundPairingRequests(DevicePairingKinds pairingKindsSupported) static : Boolean


UnpairAsync() : IAsyncOperation<DeviceUnpairingResult>

DevicePairingKinds 

None : 0,


ConfirmOnly : 1,


DisplayPin : 2,


ProvidePin : 4,


ConfirmPinMatch : 8,

DevicePairingRequestedEventArgs 

Accept() : Void


Accept(String pin) : Void


DeviceInformation { get; } : DeviceInformation


GetDeferral() : Deferral


PairingKind { get; } : DevicePairingKinds


Pin { get; } : String

DevicePairingResultStatus 

PairingCanceled : 14,


OperationAlreadyInProgress : 15,


RequiredHandlerNotRegistered : 16,


RejectedByHandler : 17,


RemoteDeviceHasAssociation : 18,


Failed : 19,

DeviceUnpairingResult 

Status { get; } : DeviceUnpairingResultStatus

DeviceUnpairingResultStatus 

Unpaired : 0,


AlreadyUnpaired : 1,


OperationAlreadyInProgress : 2,


AccessDenied : 3,


Failed : 4,


IDevicePairingSettings



GpioPinProviderValueChangedEventArgs 

ctor(ProviderGpioPinEdge edge)


Edge { get; } : ProviderGpioPinEdge

IGpioControllerProvider 

OpenPinProvider(Int32 pin, ProviderGpioSharingMode sharingMode) : IGpioPinProvider


PinCount { get; } : Int32

IGpioPinProvider 

DebounceTimeout { get; set; } : TimeSpan


GetDriveMode() : ProviderGpioPinDriveMode


IsDriveModeSupported(ProviderGpioPinDriveMode driveMode) : Boolean


PinNumber { get; } : Int32


Read() : ProviderGpioPinValue


SetDriveMode(ProviderGpioPinDriveMode value) : Void


SharingMode { get; } : ProviderGpioSharingMode


ValueChanged event : TypedEventHandler<IGpioPinProvider,GpioPinProviderValueChangedEventArgs>


Write(ProviderGpioPinValue value) : Void

IGpioProvider 

GetControllers() : IReadOnlyList<IGpioControllerProvider>

ProviderGpioPinDriveMode 

Input : 0,


Output : 1,


InputPullUp : 2,


InputPullDown : 3,


OutputOpenDrain : 4,


OutputOpenDrainPullUp : 5,


OutputOpenSource : 6,


OutputOpenSourcePullDown : 7,

ProviderGpioPinEdge 

FallingEdge : 0,


RisingEdge : 1,

ProviderGpioPinValue 

Low : 0,


High : 1,

ProviderGpioSharingMode 

Exclusive : 0,


SharedReadOnly : 1,

GpioController 

GetControllersAsync(IGpioProvider provider) static : IAsyncOperation<IReadOnlyList<GpioController>>


GetDefaultAsync() static : IAsyncOperation<GpioController>



II2cControllerProvider 

GetDeviceProvider(ProviderI2cConnectionSettings settings) : II2cDeviceProvider

II2cDeviceProvider 

DeviceId { get; } : String


Read(Byte[] buffer) : Void


ReadPartial(Byte[] buffer) : ProviderI2cTransferResult


Write(Byte[] buffer) : Void


WritePartial(Byte[] buffer) : ProviderI2cTransferResult


WriteRead(Byte[] writeBuffer, Byte[] readBuffer) : Void


WriteReadPartial(Byte[] writeBuffer, Byte[] readBuffer) : ProviderI2cTransferResult

II2cProvider 

GetControllersAsync() : IAsyncOperation<IReadOnlyList<II2cControllerProvider>>

ProviderI2cBusSpeed 

StandardMode : 0,


FastMode : 1,

ProviderI2cConnectionSettings 

BusSpeed { get; set; } : ProviderI2cBusSpeed


SharingMode { get; set; } : ProviderI2cSharingMode


SlaveAddress { get; set; } : Int32

ProviderI2cSharingMode 

Exclusive : 0,


Shared : 1,

ProviderI2cTransferResult 

BytesTransferred : UInt32


Status : ProviderI2cTransferStatus

ProviderI2cTransferStatus 

FullTransfer : 0,


PartialTransfer : 1,


SlaveAddressNotAcknowledged : 2,

I2cController 

GetControllersAsync(II2cProvider provider) static : IAsyncOperation<IReadOnlyList<I2cController>>


GetDefaultAsync() static : IAsyncOperation<I2cController>


GetDevice(I2cConnectionSettings settings) : I2cDevice


KnownPerceptionFrameSourceProperties 

DeviceId static { get; } : String

PerceptionColorFrameSource 

DeviceId { get; } : String

PerceptionDepthFrameSource 

DeviceId { get; } : String

PerceptionInfraredFrameSource 

DeviceId { get; } : String



Print3DWorkflowPrintRequestedEventArgs 

ExtendedStatus { get; set; } : Print3DWorkflowDetail


SetExtendedStatus(Print3DWorkflowDetail value) : Void


SetSourceChanged(Boolean value) : Void


Status { get; } : Print3DWorkflowStatus


Status { get; set; } : Print3DWorkflowStatus

Print3DWorkflowStatus 

Submitted : 4,


PwmController 

GetDefaultAsync() static : IAsyncOperation<PwmController>



ISensorDataThreshold

Pedometer 

GetCurrentReadings() : IReadOnlyDictionary<PedometerStepKind,PedometerReading>


GetReadingsFromTriggerDetails(SensorDataThresholdTriggerDetails triggerDetails) static : IReadOnlyList<PedometerReading>

PedometerDataThreshold 

ctor(Pedometer sensor, Int32 stepGoal)

ProximitySensor 

GetReadingsFromTriggerDetails(SensorDataThresholdTriggerDetails triggerDetails) static : IReadOnlyList<ProximitySensorReading>

ProximitySensorDataThreshold 

ctor(ProximitySensor sensor)

SensorDataThresholdTriggerDetails 

DeviceId { get; } : String


SensorType { get; } : SensorType

SensorType 

Accelerometer : 0,


ActivitySensor : 1,


Barometer : 2,


Compass : 3,


CustomSensor : 4,


Gyroscope : 5,


ProximitySensor : 6,


Inclinometer : 7,


LightSensor : 8,


OrientationSensor : 9,


Pedometer : 10,


RelativeInclinometer : 11,


RelativeOrientationSensor : 12,


SimpleOrientationSensor : 13,



ISpiControllerProvider 

GetDeviceProvider(ProviderSpiConnectionSettings settings) : ISpiDeviceProvider

ISpiDeviceProvider 

ConnectionSettings { get; } : ProviderSpiConnectionSettings


DeviceId { get; } : String


Read(Byte[] buffer) : Void


TransferFullDuplex(Byte[] writeBuffer, Byte[] readBuffer) : Void


TransferSequential(Byte[] writeBuffer, Byte[] readBuffer) : Void


Write(Byte[] buffer) : Void

ISpiProvider 

GetControllersAsync() : IAsyncOperation<IReadOnlyList<ISpiControllerProvider>>

ProviderSpiConnectionSettings 

ClockFrequency { get; set; } : Int32


ctor(Int32 chipSelectLine)


DataBitLength { get; set; } : Int32


ChipSelectLine { get; set; } : Int32


Mode { get; set; } : ProviderSpiMode


SharingMode { get; set; } : ProviderSpiSharingMode

ProviderSpiMode 

Mode0 : 0,


Mode1 : 1,


Mode2 : 2,


Mode3 : 3,

ProviderSpiSharingMode 

Exclusive : 0,


Shared : 1,

SpiController 

GetControllersAsync(ISpiProvider provider) static : IAsyncOperation<IReadOnlyList<SpiController>>


GetDefaultAsync() static : IAsyncOperation<SpiController>


GetDevice(SpiConnectionSettings settings) : SpiDevice


WiFiDirectAdvertisement 

SupportedConfigurationMethods { get; } : IList<WiFiDirectConfigurationMethod>

WiFiDirectConfigurationMethod 

ProvidePin : 0,


DisplayPin : 1,


PushButton : 2,

WiFiDirectConnectionParameters 

GetDevicePairingKinds(WiFiDirectConfigurationMethod configurationMethod) static : DevicePairingKinds


PreferenceOrderedConfigurationMethods { get; } : IList<WiFiDirectConfigurationMethod>


PreferredPairingProcedure { get; set; } : WiFiDirectPairingProcedure

WiFiDirectPairingProcedure 

GroupOwnerNegotiation : 0,


Invitation : 1,

ILowLevelDevicesAggregateProvider 

AdcControllerProvider { get; } : IAdcControllerProvider


GpioControllerProvider { get; } : IGpioControllerProvider


I2cControllerProvider { get; } : II2cControllerProvider


PwmControllerProvider { get; } : IPwmControllerProvider


SpiControllerProvider { get; } : ISpiControllerProvider

LowLevelDevicesAggregateProvider 

AdcControllerProvider { get; } : IAdcControllerProvider


ctor(IAdcControllerProvider adc, IPwmControllerProvider pwm, IGpioControllerProvider gpio, II2cControllerProvider i2c, ISpiControllerProvider spi)


GpioControllerProvider { get; } : IGpioControllerProvider


I2cControllerProvider { get; } : II2cControllerProvider


PwmControllerProvider { get; } : IPwmControllerProvider


SpiControllerProvider { get; } : ISpiControllerProvider

LowLevelDevicesController 

DefaultProvider static { get; set; } : ILowLevelDevicesAggregateProvider



ActivatableAttribute 

ctor(Type type, UInt32 version, String contractName)


ctor(Type type, UInt32 version, Type contractName)


ctor(UInt32 version, String type)


ctor(UInt32 version, Type type)

ComposableAttribute 

ctor(Type type, CompositionType compositionType, UInt32 version, String contract)


ctor(Type type, CompositionType compositionType, UInt32 version, Type contract)

ContractVersionAttribute 

ctor(String contract, UInt32 version)

DeprecatedAttribute 

ctor(String message, DeprecationType type, UInt32 version, String contract)


ctor(String message, DeprecationType type, UInt32 version, Type contract)

PreviousContractVersionAttribute 

ctor(String contract, UInt32 versionLow, UInt32 versionHigh)


ctor(String contract, UInt32 versionLow, UInt32 versionHigh, String newContract)


ctor(Type contract, UInt32 versionLow, UInt32 versionHigh)


ctor(Type contract, UInt32 versionLow, UInt32 versionHigh, Type newContract)

StaticAttribute 

ctor(Type type, UInt32 version, String contractName)


ctor(Type type, UInt32 version, Type contractName)



GameBar 

IsInputRedirected static { get; } : Boolean


IsInputRedirectedChanged static event : EventHandler<Object>


VisibilityChanged static event : EventHandler<Object>


Visible static { get; } : Boolean



GameSaveContainer 

ReadAsync(IReadOnlyDictionary<String,IBuffer> blobsToRead) : IAsyncOperation<GameSaveOperationResult>


ReadAsync(IReadOnlyDictionary<String,IBuffer> blobsToWrite) : IAsyncOperation<GameSaveOperationResult>



DirectXAlphaMode 

Unspecified : 0,


Premultiplied : 1,


Straight : 2,


Ignore : 3,


DisplayInformation 

DiagonalSizeInInches { get; } : Nullable<Double>


HolographicAdapterId 

HighPart : Int32


LowPart : UInt32

HolographicCamera 

Id { get; } : UInt32


IsStereo { get; } : Boolean


RenderTargetSize { get; } : Size


SetFarPlaneDistance(Double value) : Void


SetNearPlaneDistance(Double value) : Void


ViewportScaleFactor { get; set; } : Double

HolographicCameraPose 

FarPlaneDistance { get; } : Double


HolographicCamera { get; } : HolographicCamera


NearPlaneDistance { get; } : Double


ProjectionTransform { get; } : HolographicStereoTransform


TryGetCullingFrustum(SpatialCoordinateSystem coordinateSystem) : Nullable<SpatialBoundingFrustum>


TryGetViewTransform(SpatialCoordinateSystem coordinateSystem) : Nullable<HolographicStereoTransform>


TryGetVisibleFrustum(SpatialCoordinateSystem coordinateSystem) : Nullable<SpatialBoundingFrustum>


Viewport { get; } : Rect

HolographicCameraRenderingParameters 

Direct3D11BackBuffer { get; } : IDirect3DSurface


Direct3D11Device { get; } : IDirect3DDevice


SetFocusPoint(SpatialCoordinateSystem coordinateSystem, Vector3 position) : Void


SetFocusPoint(SpatialCoordinateSystem coordinateSystem, Vector3 position, Vector3 normal) : Void


SetFocusPoint(SpatialCoordinateSystem coordinateSystem, Vector3 position, Vector3 normal, Vector3 linearVelocity) : Void

HolographicFrame 

AddedCameras { get; } : IReadOnlyList<HolographicCamera>


CurrentPrediction { get; } : HolographicFramePrediction


Duration { get; } : TimeSpan


GetRenderingParameters(HolographicCameraPose cameraPose) : HolographicCameraRenderingParameters


PresentUsingCurrentPrediction() : HolographicFramePresentResult


PresentUsingCurrentPrediction(HolographicFramePresentWaitBehavior waitBehavior) : HolographicFramePresentResult


RemovedCameras { get; } : IReadOnlyList<HolographicCamera>


UpdateCurrentPrediction() : Void


WaitForFrameToFinish() : Void

HolographicFramePrediction 

CameraPoses { get; } : IReadOnlyList<HolographicCameraPose>


Timestamp { get; } : PerceptionTimestamp

HolographicFramePresentResult 

Success : 0,


DeviceRemoved : 1,

HolographicFramePresentWaitBehavior 

WaitForFrameToFinish : 0,


DoNotWaitForFrameToFinish : 1,

HolographicSpace 

CameraAdded event : TypedEventHandler<HolographicSpace,HolographicSpaceCameraAddedEventArgs>


CameraRemoved event : TypedEventHandler<HolographicSpace,HolographicSpaceCameraRemovedEventArgs>


CreateForCoreWindow(CoreWindow window) static : HolographicSpace


CreateNextFrame() : HolographicFrame


PrimaryAdapterId { get; } : HolographicAdapterId


SetDirect3D11Device(IDirect3DDevice value) : Void

HolographicSpaceCameraAddedEventArgs 

Camera { get; } : HolographicCamera


GetDeferral() : Deferral

HolographicSpaceCameraRemovedEventArgs 

Camera { get; } : HolographicCamera

HolographicStereoTransform 

Left : Matrix4x4


Right : Matrix4x4


Printing3DBufferFormat 

Printing3DDouble : 500,


Printing3DUInt : 501,

Printing3DColorMaterial 

Color { get; set; } : Color

Printing3DTexture2CoordMaterialGroup 

Texture { get; set; } : Printing3DModelTexture



PackageInstallState 

Paused : 6,



OrchestrationContract



AppCapture 

CapturingChanged event : TypedEventHandler<AppCapture,Object>


GetForCurrentView() static : AppCapture


IsCapturingAudio { get; } : Boolean


IsCapturingVideo { get; } : Boolean

AppCaptureAlternateShortcutKeys 

ToggleMicrophoneCaptureKey { get; set; } : VirtualKey


ToggleMicrophoneCaptureKeyModifiers { get; set; } : VirtualKeyModifiers

AppCaptureSettings 

IsMicrophoneCaptureEnabled { get; set; } : Boolean


MediaBinder 

Binding event : TypedEventHandler<MediaBinder,MediaBindingEventArgs>


Source { get; } : MediaSource


Token { get; set; } : String

MediaBindingEventArgs 

Canceled event : TypedEventHandler<MediaBindingEventArgs,Object>


GetDeferral() : Deferral


MediaBinder { get; } : MediaBinder


SetStream(IRandomAccessStream stream, String contentType) : Void


SetStreamReference(IRandomAccessStreamReference stream, String contentType) : Void


SetUri(Uri uri) : Void

MediaSource 

CreateFromMediaBinder(MediaBinder binder) static : MediaSource


Reset() : Void


State { get; } : MediaSourceState


StateChanged event : TypedEventHandler<MediaSource,MediaSourceStateChangedEventArgs>

MediaSourceState 

Initial : 0,


Opening : 1,


Opened : 2,


Failed : 3,


Closed : 4,

MediaSourceStateChangedEventArgs 

NewState { get; } : MediaSourceState


OldState { get; } : MediaSourceState


DialDevice 

FriendlyName { get; } : String


Thumbnail { get; } : IRandomAccessStreamReference


MediaPlaybackItem 

FindFromMediaSource(MediaSource source) static : MediaPlaybackItem

MediaPlaybackList 

MaxPrefetchTime { get; set; } : Nullable<TimeSpan>


SetShuffledItems(IEnumerable<MediaPlaybackItem> value) : Void


ShuffledItems { get; } : IReadOnlyList<MediaPlaybackItem>


StartingItem { get; set; } : MediaPlaybackItem

MediaPlayer 

AddAudioEffect(String activatableClassId, Boolean effectOptional, IPropertySet configuration) : Void


RemoveAllEffects() : Void


ProtectionCapabilities 

IsTypeSupported(String type, String keySystem) : ProtectionCapabilityResult

ProtectionCapabilityResult 

NotSupported : 0,


Maybe : 1,


Probably : 2,



AdaptiveMediaSource 

AdvancedSettings { get; } : AdaptiveMediaSourceAdvancedSettings

AdaptiveMediaSourceAdvancedSettings 

AllSegmentsIndependent { get; set; } : Boolean


BitrateDowngradeTriggerRatio { get; set; } : Nullable<Double>


DesiredBitrateHeadroomRatio { get; set; } : Nullable<Double>



HeadPose 

ForwardDirection { get; } : Vector3


Position { get; } : Vector3


UpDirection { get; } : Vector3



SpatialSurfaceInfo 

Id { get; } : Guid


TryComputeLatestMeshAsync(Double maxTrianglesPerCubicMeter) : IAsyncOperation<SpatialSurfaceMesh>


TryComputeLatestMeshAsync(Double maxTrianglesPerCubicMeter, SpatialSurfaceMeshOptions options) : IAsyncOperation<SpatialSurfaceMesh>


TryGetBounds(SpatialCoordinateSystem coordinateSystem) : Nullable<SpatialBoundingOrientedBox>


UpdateTime { get; } : DateTimeOffset

SpatialSurfaceMesh 

CoordinateSystem { get; } : SpatialCoordinateSystem


SurfaceInfo { get; } : SpatialSurfaceInfo


TriangleIndices { get; } : SpatialSurfaceMeshBuffer


VertexNormals { get; } : SpatialSurfaceMeshBuffer


VertexPositions { get; } : SpatialSurfaceMeshBuffer


VertexPositionScale { get; } : Vector3

SpatialSurfaceMeshBuffer 

Data { get; } : IBuffer


ElementCount { get; } : UInt32


Format { get; } : DirectXPixelFormat


Stride { get; } : UInt32

SpatialSurfaceMeshOptions 

IncludeVertexNormals { get; set; } : Boolean


SupportedTriangleIndexFormats static { get; } : IReadOnlyList<DirectXPixelFormat>


SupportedVertexNormalFormats static { get; } : IReadOnlyList<DirectXPixelFormat>


SupportedVertexPositionFormats static { get; } : IReadOnlyList<DirectXPixelFormat>


TriangleIndexFormat { get; set; } : DirectXPixelFormat


VertexNormalFormat { get; set; } : DirectXPixelFormat


VertexPositionFormat { get; set; } : DirectXPixelFormat

SpatialSurfaceObserver 

GetObservedSurfaces() : IReadOnlyDictionary<Guid,SpatialSurfaceInfo>


ObservedSurfacesChanged event : TypedEventHandler<SpatialSurfaceObserver,Object>


RequestAccessAsync() static : IAsyncOperation<SpatialPerceptionAccessStatus>


SetBoundingVolume(SpatialBoundingVolume bounds) : Void


SetBoundingVolumes(IEnumerable<SpatialBoundingVolume> bounds) : Void

SpatialAnchor 

CoordinateSystem { get; } : SpatialCoordinateSystem


RawCoordinateSystem { get; } : SpatialCoordinateSystem


RawCoordinateSystemAdjusted event : TypedEventHandler<SpatialAnchor,SpatialAnchorRawCoordinateSystemAdjustedEventArgs>


TryCreateRelativeTo(SpatialCoordinateSystem coordinateSystem) static : SpatialAnchor


TryCreateRelativeTo(SpatialCoordinateSystem coordinateSystem, Vector3 position) static : SpatialAnchor


TryCreateRelativeTo(SpatialCoordinateSystem coordinateSystem, Vector3 position, Quaternion orientation) static : SpatialAnchor

SpatialAnchorManager 

RequestStoreAsync() static : IAsyncOperation<SpatialAnchorStore>

SpatialAnchorRawCoordinateSystemAdjustedEventArgs 

OldRawCoordinateSystemToNewRawCoordinateSystemTransform { get; } : Matrix4x4

SpatialAnchorStore 

Clear() : Void


GetAllSavedAnchors() : IReadOnlyDictionary<String,SpatialAnchor>


Remove(String id) : Void


TrySave(String id, SpatialAnchor anchor) : Boolean

SpatialAnchorTransferManager 

RequestAccessAsync() static : IAsyncOperation<SpatialPerceptionAccessStatus>


TryExportAnchorsAsync(IEnumerable<KeyValuePair<String,SpatialAnchor>> anchors, IOutputStream stream) static : IAsyncOperation<Boolean>


TryImportAnchorsAsync(IInputStream stream) static : IAsyncOperation<IReadOnlyDictionary<String,SpatialAnchor>>

SpatialBoundingBox 

Center : Vector3


Extents : Vector3

SpatialBoundingFrustum 

Bottom : Plane


Far : Plane


Left : Plane


Near : Plane


Right : Plane


Top : Plane

SpatialBoundingOrientedBox 

Center : Vector3


Extents : Vector3


Orientation : Quaternion

SpatialBoundingSphere 

Center : Vector3


Radius : Single

SpatialBoundingVolume 

FromBox(SpatialCoordinateSystem coordinateSystem, SpatialBoundingBox box) static : SpatialBoundingVolume


FromFrustum(SpatialCoordinateSystem coordinateSystem, SpatialBoundingFrustum frustum) static : SpatialBoundingVolume


FromOrientedBox(SpatialCoordinateSystem coordinateSystem, SpatialBoundingOrientedBox box) static : SpatialBoundingVolume


FromSphere(SpatialCoordinateSystem coordinateSystem, SpatialBoundingSphere sphere) static : SpatialBoundingVolume

SpatialCoordinateSystem 

TryGetTransformTo(SpatialCoordinateSystem target) : Nullable<Matrix4x4>

SpatialLocatability 

Unavailable : 0,


OrientationOnly : 1,


PositionalTrackingActivating : 2,


PositionalTrackingActive : 3,


PositionalTrackingInhibited : 4,

SpatialLocation 

AbsoluteAngularAcceleration { get; } : Quaternion


AbsoluteAngularVelocity { get; } : Quaternion


AbsoluteLinearAcceleration { get; } : Vector3


AbsoluteLinearVelocity { get; } : Vector3


Orientation { get; } : Quaternion


Position { get; } : Vector3

SpatialLocator 

CreateAttachedFrameOfReferenceAtCurrentHeading() : SpatialLocatorAttachedFrameOfReference


CreateAttachedFrameOfReferenceAtCurrentHeading(Vector3 relativePosition) : SpatialLocatorAttachedFrameOfReference


CreateAttachedFrameOfReferenceAtCurrentHeading(Vector3 relativePosition, Quaternion relativeOrientation) : SpatialLocatorAttachedFrameOfReference


CreateAttachedFrameOfReferenceAtCurrentHeading(Vector3 relativePosition, Quaternion relativeOrientation, Double relativeHeadingInRadians) : SpatialLocatorAttachedFrameOfReference


CreateStationaryFrameOfReferenceAtCurrentLocation() : SpatialStationaryFrameOfReference


CreateStationaryFrameOfReferenceAtCurrentLocation(Vector3 relativePosition) : SpatialStationaryFrameOfReference


CreateStationaryFrameOfReferenceAtCurrentLocation(Vector3 relativePosition, Quaternion relativeOrientation) : SpatialStationaryFrameOfReference


CreateStationaryFrameOfReferenceAtCurrentLocation(Vector3 relativePosition, Quaternion relativeOrientation, Double relativeHeadingInRadians) : SpatialStationaryFrameOfReference


GetDefault() static : SpatialLocator


Locatability { get; } : SpatialLocatability


LocatabilityChanged event : TypedEventHandler<SpatialLocator,Object>


PositionalTrackingDeactivating event : TypedEventHandler<SpatialLocator,SpatialLocatorPositionalTrackingDeactivatingEventArgs>


TryLocateAtTimestamp(PerceptionTimestamp timestamp, SpatialCoordinateSystem coordinateSystem) : SpatialLocation

SpatialLocatorAttachedFrameOfReference 

AdjustHeading(Double headingOffsetInRadians) : Void


GetStationaryCoordinateSystemAtTimestamp(PerceptionTimestamp timestamp) : SpatialCoordinateSystem


RelativeOrientation { get; set; } : Quaternion


RelativePosition { get; set; } : Vector3


TryGetRelativeHeadingAtTimestamp(PerceptionTimestamp timestamp) : Nullable<Double>

SpatialLocatorPositionalTrackingDeactivatingEventArgs 

Canceled { get; set; } : Boolean

SpatialPerceptionAccessStatus 

Unspecified : 0,


Allowed : 1,


DeniedByUser : 2,


DeniedBySystem : 3,

SpatialStationaryFrameOfReference 

CoordinateSystem { get; } : SpatialCoordinateSystem

PerceptionTimestamp 

PredictionAmount { get; } : TimeSpan


TargetTime { get; } : DateTimeOffset

PerceptionTimestampHelper 

FromHistoricalTargetTime(DateTimeOffset targetTime) static : PerceptionTimestamp





WebTokenRequest 

AppProperties { get; } : IDictionary<String,String>


WebAccountManager 

PullCookiesAsync(String uriString, String callerPFN) static : IAsyncAction


KeyCredential 

RetrievePublicKey(CryptographicPublicKeyBlobType blobType) : IBuffer


DataProtectionStatus 

LicenseExpired : 4,


AccessSuspended : 5,

EnforcementLevel 

NoProtection : 0,


Silent : 1,


Override : 2,


Block : 3,

FileProtectionManager 

IsContainerAsync(IStorageFile file) static : IAsyncOperation<Boolean>


LoadFileFromContainerAsync(IStorageFile containerFile, IStorageItem target, NameCollisionOption collisionOption) static : IAsyncOperation<ProtectedContainerImportResult>


SaveFileAsContainerAsync(IStorageFile protectedFile, IEnumerable<String> sharedWithIdentities) static : IAsyncOperation<ProtectedContainerExportResult>

FileProtectionStatus 

LicenseExpired : 8,


AccessSuspended : 9,

ProtectedImportExportStatus 

LicenseExpired : 6,


AccessSuspended : 7,

ProtectionPolicyManager 

GetEnforcementLevel(String identity) static : EnforcementLevel


HasContentBeenRevokedSince(String identity, DateTimeOffset since) static : Boolean


CheckAccessForApp(String sourceIdentity, String appPackageFamilyName) static : ProtectionPolicyEvaluationResult


IsProtectionEnabled static { get; } : Boolean


IsProtectionUnderLockRequired(String identity) static : Boolean


IsUserDecryptionAllowed(String identity) static : Boolean


PolicyChanged static event : EventHandler<Object>


RequestAccessForAppAsync(String sourceIdentity, String appPackageFamilyName) static : IAsyncOperation<ProtectionPolicyEvaluationResult>




GuidanceAudioNotificationKind 

Maneuver : 0,


Route : 1,


Gps : 2,


SpeedLimit : 3,


Traffic : 4,


TrafficCamera : 5,

GuidanceAudioNotificationRequestedEventArgs 

AudioFilePaths { get; } : IReadOnlyList<String>


AudioNotification { get; } : GuidanceAudioNotificationKind


AudioText { get; } : String

GuidanceNavigator 

AudioNotificationRequested event : TypedEventHandler<GuidanceNavigator,GuidanceAudioNotificationRequestedEventArgs>


IsGuidanceAudioMuted { get; set; } : Boolean


UseAppProvidedVoice static { get; } : Boolean

MapService 

DataAttributions static { get; } : String


DownloadsFolder 

CreateFileForUserAsync(User user, String desiredName) static : IAsyncOperation<StorageFile>


CreateFileForUserAsync(User user, String desiredName, CreationCollisionOption option) static : IAsyncOperation<StorageFile>


CreateFolderForUserAsync(User user, String desiredName) static : IAsyncOperation<StorageFolder>


CreateFolderForUserAsync(User user, String desiredName, CreationCollisionOption option) static : IAsyncOperation<StorageFolder>

KnownFolderId 

AppCaptures : 0,


CameraRoll : 1,


DocumentsLibrary : 2,


HomeGroup : 3,


MediaServerDevices : 4,


MusicLibrary : 5,


Objects3D : 6,


PicturesLibrary : 7,


Playlists : 8,


RecordedCalls : 9,


RemovableDevices : 10,


SavedPictures : 11,


Screenshots : 12,


VideosLibrary : 13,

KnownFolders 

GetFolderForUserAsync(User user, KnownFolderId folderId) static : IAsyncOperation<StorageFolder>

StorageLibrary 

GetLibraryForUserAsync(User user, KnownLibraryId libraryId) static : IAsyncOperation<StorageLibrary>



PlatformDataCollectionLevel 

Security : 0,


Basic : 1,


Enhanced : 2,


Full : 3,

PlatformDiagnosticsAndUsageDataSettings 

CanCollectDiagnostics(PlatformDataCollectionLevel level) static : Boolean


CollectionLevel static { get; } : PlatformDataCollectionLevel


CollectionLevelChanged static event : EventHandler<Object>

MemoryManager 

TrySetAppMemoryUsageLimit(UInt64 value) static : Boolean

ProcessLauncher 

RunToCompletionAsync(String fileName, String args) static : IAsyncOperation<ProcessLauncherResult>


RunToCompletionAsync(String fileName, String args, ProcessLauncherOptions options) static : IAsyncOperation<ProcessLauncherResult>

ProcessLauncherOptions 

StandardError { get; set; } : IOutputStream


StandardInput { get; set; } : IInputStream


StandardOutput { get; set; } : IOutputStream


WorkingDirectory { get; set; } : String

ProcessLauncherResult 

ExitCode { get; } : UInt32




AnimationEndedEventArgs


AnimationEndReason

ColorKeyFrameAnimation 

InsertKeyFrame(Single normalizedProgressKey, Color value) : Void


InsertKeyFrame(Single normalizedProgressKey, Color value, CompositionEasingFunction easingFunction) : Void


InterpolationColorSpace { get; set; } : CompositionColorSpace

CompositionAnimation 

SetColorParameter(String key, Color value) : Void


SetQuaternionParameter(String key, Quaternion value) : Void

CompositionBackfaceVisibility 

Inherit : 0,


Visible : 1,


Hidden : 2,


CompositionBatchCompletedEventArgs

CompositionBatchTypes 

None : 0,


Animation : 1,


Effect : 2,

CompositionBitmapInterpolationMode 

NearestNeighbor : 0,


Linear : 1,

CompositionBorderMode 

Inherit : 0,


Soft : 1,


Hard : 2,


CompositionBrush

CompositionColorBrush 

Color { get; set; } : Color

CompositionColorSpace 

Auto : 0,


Hsl : 1,


Rgb : 2,

CompositionCommitBatch 

Completed event : TypedEventHandler<Object,CompositionBatchCompletedEventArgs>


IsActive { get; } : Boolean


IsEnded { get; } : Boolean

CompositionCompositeMode 

Inherit : 0,


SourceOver : 1,


DestinationInvert : 2,

CompositionDrawingSurface 

AlphaMode { get; } : DirectXAlphaMode


PixelFormat { get; } : DirectXPixelFormat


Size { get; } : Size


CompositionEffect

CompositionEffectBrush 

GetSourceParameter(String name) : CompositionBrush


SetSourceParameter(String name, CompositionBrush source) : Void

CompositionEffectFactory 

CompleteLoadAsync() : IAsyncOperation<CompositionEffectFactoryLoadResult>


CreateBrush() : CompositionEffectBrush


CreateEffect() : CompositionEffect


ExtendedError { get; } : Exception


LoadStatus { get; } : CompositionEffectFactoryLoadStatus


CompositionEffectFactoryLoadResult

CompositionEffectFactoryLoadStatus 

Other : -1,

CompositionGraphicsDevice 

CreateDrawingSurface(Size sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode) : CompositionDrawingSurface


CreateImageFromUri(Uri uri) : CompositionImage


CreateImageFromUri(Uri uri, CompositionImageOptions options) : CompositionImage


RenderingDeviceReplaced event : TypedEventHandler<CompositionGraphicsDevice,RenderingDeviceReplacedEventArgs>


CompositionImage


CompositionImageLoadResult


CompositionImageLoadStatus


CompositionImageOptions


CompositionImageProgressStage

CompositionObject 

ConnectAnimation(String propertyName, CompositionAnimation animation) : CompositionPropertyAnimator


DisconnectAnimation(String propertyName) : Void


StartAnimation(String propertyName, CompositionAnimation animation) : Void


StopAnimation(String propertyName) : Void


CompositionPropertyAnimator

CompositionPropertySet 

InsertColor(String propertyName, Color value) : Void


InsertQuaternion(String propertyName, Quaternion value) : Void


TryGetColor(String propertyName, Color& value) : CompositionGetValueStatus


TryGetQuaternion(String propertyName, Quaternion& value) : CompositionGetValueStatus

CompositionScopedBatch 

Completed event : TypedEventHandler<Object,CompositionBatchCompletedEventArgs>


End() : Void


IsActive { get; } : Boolean


IsEnded { get; } : Boolean


Resume() : Void


Suspend() : Void

CompositionSurfaceBrush 

BitmapInterpolationMode { get; set; } : CompositionBitmapInterpolationMode


HorizontalAlignmentRatio { get; set; } : Single


Stretch { get; set; } : CompositionStretch


Surface { get; set; } : ICompositionSurface


VerticalAlignmentRatio { get; set; } : Single

Compositor 

CreateColorBrush() : CompositionColorBrush


CreateColorBrush(Color color) : CompositionColorBrush


CreateColorKeyFrameAnimation() : ColorKeyFrameAnimation


CreateEffectVisual() : EffectVisual


CreateImageVisual() : ImageVisual


CreateQuaternionKeyFrameAnimation() : QuaternionKeyFrameAnimation


CreateScopedBatch(CompositionBatchTypes batchType) : CompositionScopedBatch


CreateSolidColorVisual() : SolidColorVisual


CreateSpriteVisual() : SpriteVisual


CreateSurfaceBrush() : CompositionSurfaceBrush


CreateSurfaceBrush(ICompositionSurface surface) : CompositionSurfaceBrush


DefaultGraphicsDevice { get; } : CompositionGraphicsDevice


GetCommitBatch(CompositionBatchTypes batchType) : CompositionCommitBatch


EffectVisual


ImageVisual

QuaternionKeyFrameAnimation 

InsertKeyFrame(Single normalizedProgressKey, Quaternion value) : Void


InsertKeyFrame(Single normalizedProgressKey, Quaternion value, CompositionEasingFunction easingFunction) : Void

RenderingDeviceReplacedEventArgs 

GraphicsDevice { get; } : CompositionGraphicsDevice


SolidColorVisual

SpriteVisual 

Brush { get; set; } : CompositionBrush

Visual 

AnchorPoint { get; set; } : Vector2


BackfaceVisibility { get; set; } : CompositionBackfaceVisibility


BorderMode { get; set; } : CompositionBorderMode


CompositeMode { get; set; } : CompositionCompositeMode


IsVisible { get; set; } : Boolean


RotationAngleInDegrees { get; set; } : Single


CoreWindow 

PointerRoutedAway event : TypedEventHandler<ICorePointerRedirector,PointerEventArgs>


PointerRoutedReleased event : TypedEventHandler<ICorePointerRedirector,PointerEventArgs>


PointerRoutedTo event : TypedEventHandler<ICorePointerRedirector,PointerEventArgs>

ICorePointerRedirector 

PointerRoutedAway event : TypedEventHandler<ICorePointerRedirector,PointerEventArgs>


PointerRoutedReleased event : TypedEventHandler<ICorePointerRedirector,PointerEventArgs>


PointerRoutedTo event : TypedEventHandler<ICorePointerRedirector,PointerEventArgs>



SpatialGestureRecognizer 

CancelPendingGestures() : Void


CaptureInteraction(SpatialInteraction interaction) : Void


ctor(SpatialGestureSettings settings)


GestureSettings { get; } : SpatialGestureSettings


HoldCanceled event : TypedEventHandler<SpatialGestureRecognizer,SpatialHoldCanceledEventArgs>


HoldCompleted event : TypedEventHandler<SpatialGestureRecognizer,SpatialHoldCompletedEventArgs>


HoldStarted event : TypedEventHandler<SpatialGestureRecognizer,SpatialHoldStartedEventArgs>


ManipulationCanceled event : TypedEventHandler<SpatialGestureRecognizer,SpatialManipulationCanceledEventArgs>


ManipulationCompleted event : TypedEventHandler<SpatialGestureRecognizer,SpatialManipulationCompletedEventArgs>


ManipulationStarted event : TypedEventHandler<SpatialGestureRecognizer,SpatialManipulationStartedEventArgs>


ManipulationUpdated event : TypedEventHandler<SpatialGestureRecognizer,SpatialManipulationUpdatedEventArgs>


NavigationCanceled event : TypedEventHandler<SpatialGestureRecognizer,SpatialNavigationCanceledEventArgs>


NavigationCompleted event : TypedEventHandler<SpatialGestureRecognizer,SpatialNavigationCompletedEventArgs>


NavigationStarted event : TypedEventHandler<SpatialGestureRecognizer,SpatialNavigationStartedEventArgs>


NavigationUpdated event : TypedEventHandler<SpatialGestureRecognizer,SpatialNavigationUpdatedEventArgs>


RecognitionEnded event : TypedEventHandler<SpatialGestureRecognizer,SpatialRecognitionEndedEventArgs>


RecognitionStarted event : TypedEventHandler<SpatialGestureRecognizer,SpatialRecognitionStartedEventArgs>


Tapped event : TypedEventHandler<SpatialGestureRecognizer,SpatialTappedEventArgs>


TrySetGestureSettings(SpatialGestureSettings settings) : Boolean

SpatialGestureSettings 

None : 0,


Tap : 1,


DoubleTap : 2,


Hold : 4,


ManipulationTranslate : 8,


NavigationX : 16,


NavigationY : 32,


NavigationZ : 64,


NavigationRailsX : 128,


NavigationRailsY : 256,


NavigationRailsZ : 512,

SpatialHoldCanceledEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind

SpatialHoldCompletedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind

SpatialHoldStartedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


TryGetPointerPose(SpatialCoordinateSystem coordinateSystem) : SpatialPointerPose

SpatialInteraction 

SourceState { get; } : SpatialInteractionSourceState

SpatialInteractionDetectedEventArgs 

Interaction { get; } : SpatialInteraction


InteractionSourceKind { get; } : SpatialInteractionSourceKind


TryGetPointerPose(SpatialCoordinateSystem coordinateSystem) : SpatialPointerPose

SpatialInteractionManager 

GetDetectedSourcesAtTimestamp(PerceptionTimestamp timeStamp) : IReadOnlyList<SpatialInteractionSourceState>


GetForCurrentView() static : SpatialInteractionManager


InteractionDetected event : TypedEventHandler<SpatialInteractionManager,SpatialInteractionDetectedEventArgs>


SourceDetected event : TypedEventHandler<SpatialInteractionManager,SpatialInteractionSourceEventArgs>


SourceLost event : TypedEventHandler<SpatialInteractionManager,SpatialInteractionSourceEventArgs>


SourcePressed event : TypedEventHandler<SpatialInteractionManager,SpatialInteractionSourceEventArgs>


SourceReleased event : TypedEventHandler<SpatialInteractionManager,SpatialInteractionSourceEventArgs>


SourceUpdated event : TypedEventHandler<SpatialInteractionManager,SpatialInteractionSourceEventArgs>

SpatialInteractionSource 

Id { get; } : UInt32


Kind { get; } : SpatialInteractionSourceKind

SpatialInteractionSourceEventArgs 

State { get; } : SpatialInteractionSourceState

SpatialInteractionSourceKind 

Other : 0,


Hand : 1,


Voice : 2,


Controller : 3,

SpatialInteractionSourceLocation 

Position { get; } : Nullable<Vector3>


Velocity { get; } : Nullable<Vector3>

SpatialInteractionSourceProperties 

SourceLossRisk { get; } : Double


TryGetLocation(SpatialCoordinateSystem coordinateSystem) : SpatialInteractionSourceLocation


TryGetSourceLossMitigationDirection(SpatialCoordinateSystem coordinateSystem) : Nullable<Vector3>

SpatialInteractionSourceState 

IsPressed { get; } : Boolean


Properties { get; } : SpatialInteractionSourceProperties


Source { get; } : SpatialInteractionSource


Timestamp { get; } : PerceptionTimestamp


TryGetPointerPose(SpatialCoordinateSystem coordinateSystem) : SpatialPointerPose

SpatialManipulationCanceledEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind

SpatialManipulationCompletedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


TryGetCumulativeDelta(SpatialCoordinateSystem coordinateSystem) : SpatialManipulationDelta

SpatialManipulationDelta 

Translation { get; } : Vector3

SpatialManipulationStartedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


TryGetPointerPose(SpatialCoordinateSystem coordinateSystem) : SpatialPointerPose

SpatialManipulationUpdatedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


TryGetCumulativeDelta(SpatialCoordinateSystem coordinateSystem) : SpatialManipulationDelta

SpatialNavigationCanceledEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind

SpatialNavigationCompletedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


NormalizedOffset { get; } : Vector3

SpatialNavigationStartedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


IsNavigatingX { get; } : Boolean


IsNavigatingY { get; } : Boolean


IsNavigatingZ { get; } : Boolean


TryGetPointerPose(SpatialCoordinateSystem coordinateSystem) : SpatialPointerPose

SpatialNavigationUpdatedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


NormalizedOffset { get; } : Vector3

SpatialPointerPose 

Head { get; } : HeadPose


Timestamp { get; } : PerceptionTimestamp


TryGetAtTimestamp(SpatialCoordinateSystem coordinateSystem, PerceptionTimestamp timestamp) static : SpatialPointerPose

SpatialRecognitionEndedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind

SpatialRecognitionStartedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


IsGesturePossible(SpatialGestureSettings gesture) : Boolean


TryGetPointerPose(SpatialCoordinateSystem coordinateSystem) : SpatialPointerPose

SpatialTappedEventArgs 

InteractionSourceKind { get; } : SpatialInteractionSourceKind


TapCount { get; } : UInt32


TryGetPointerPose(SpatialCoordinateSystem coordinateSystem) : SpatialPointerPose

KeyboardDeliveryInterceptor 

GetForCurrentView() static : KeyboardDeliveryInterceptor


IsInterceptionEnabledWhenInForeground { get; set; } : Boolean


KeyDown event : TypedEventHandler<KeyboardDeliveryInterceptor,KeyEventArgs>


KeyUp event : TypedEventHandler<KeyboardDeliveryInterceptor,KeyEventArgs>


JumpList 

IsSupported() static : Boolean


Items { get; } : IList<JumpListItem>


LoadCurrentAsync() static : IAsyncOperation<JumpList>


SaveAsync() : IAsyncAction


SystemGroupKind { get; set; } : JumpListSystemGroupKind

JumpListItem 

Arguments { get; } : String


CreateSeparator() static : JumpListItem


CreateWithArguments(String arguments, String displayName) static : JumpListItem


Description { get; set; } : String


DisplayName { get; set; } : String


GroupName { get; set; } : String


Kind { get; } : JumpListItemKind


Logo { get; set; } : Uri


RemovedByUser { get; } : Boolean

JumpListItemKind 

Arguments : 0,


Separator : 1,

JumpListSystemGroupKind 

None : 0,


Frequent : 1,


Recent : 2,



CoreTextEditContext 

NotifyFocusLeaveCompleted event : TypedEventHandler<CoreTextEditContext,Object>


ApplicationViewTransferContext 

DataPackageFormatId static { get; } : String


ViewId { get; set; } : Int32


WebUIDevicePairingActivatedEventArgs 

ActivatedOperation { get; } : ActivatedOperation


DeviceInformation { get; } : DeviceInformation


Kind { get; } : ActivationKind


PreviousExecutionState { get; } : ApplicationExecutionState


SplashScreen { get; } : SplashScreen




AutomationLandmarkType 

None : 0,


Custom : 1,


Form : 2,


Main : 3,


Navigation : 4,


Search : 5,

AutomationPeer 

GetLandmarkType() : AutomationLandmarkType


GetLocalizedLandmarkType() : String

AutomationElementIdentifiers 

LandmarkTypeProperty static { get; } : AutomationProperty


LocalizedLandmarkTypeProperty static { get; } : AutomationProperty

AutomationProperties 

GetLandmarkType(DependencyObject element) static : AutomationLandmarkType


GetLocalizedLandmarkType(DependencyObject element) static : String


LandmarkTypeProperty static { get; } : DependencyProperty


LocalizedLandmarkTypeProperty static { get; } : DependencyProperty


SetLandmarkType(DependencyObject element, AutomationLandmarkType value) static : Void


SetLocalizedLandmarkType(DependencyObject element, String value) static : Void



MapActualCameraChangedEventArgs 

ChangeReason { get; } : MapCameraChangeReason

MapActualCameraChangingEventArgs 

ChangeReason { get; } : MapCameraChangeReason

MapCameraChangeReason 

System : 0,


UserInteraction : 1,


Programmatic : 2,

MapControl 

MapRightTapped event : TypedEventHandler<MapControl,MapRightTappedEventArgs>

MapControlBusinessLandmarkClickEventArgs 

LocalLocations { get; } : IReadOnlyList<LocalLocation>

MapControlBusinessLandmarkRightTappedEventArgs 

LocalLocations { get; } : IReadOnlyList<LocalLocation>

MapControlDataHelper 

BusinessLandmarkClick event : TypedEventHandler<MapControl,MapControlBusinessLandmarkClickEventArgs>


BusinessLandmarkRightTapped event : TypedEventHandler<MapControl,MapControlBusinessLandmarkRightTappedEventArgs>


ctor(MapControl map)


TransitFeatureClick event : TypedEventHandler<MapControl,MapControlTransitFeatureClickEventArgs>


TransitFeatureRightTapped event : TypedEventHandler<MapControl,MapControlTransitFeatureRightTappedEventArgs>

MapControlTransitFeatureClickEventArgs 

DisplayName { get; } : String


Location { get; } : Geopoint


TransitProperties { get; } : IReadOnlyDictionary<String,Object>

MapControlTransitFeatureRightTappedEventArgs 

DisplayName { get; } : String


Location { get; } : Geopoint


TransitProperties { get; } : IReadOnlyDictionary<String,Object>

MapLoadingStatus 

DataUnavailable : 2,

MapPolygon 

Paths { get; } : IList<Geopath>

MapRightTappedEventArgs 

Location { get; } : Geopoint


Position { get; } : Point

MapTargetCameraChangedEventArgs 

ChangeReason { get; } : MapCameraChangeReason


ComboBoxTemplateSettings 

DropDownContentMinWidth { get; } : Double

CommandBarTemplateSettings 

OverflowContentMaxWidth { get; } : Double

MenuFlyoutPresenterTemplateSettings 

FlyoutContentMinWidth { get; } : Double

MenuFlyoutPresenter 

TemplateSettings { get; } : MenuFlyoutPresenterTemplateSettings

RichEditBox 

ClipboardCopyFormat { get; set; } : RichEditClipboardFormat


ClipboardCopyFormatProperty static { get; } : DependencyProperty


GetLinguisticAlternativesAsync() : IAsyncOperation<IReadOnlyList<String>>

RichEditClipboardFormat 

AllFormats : 0,


PlainText : 1,

TextBox 

GetLinguisticAlternativesAsync() : IAsyncOperation<IReadOnlyList<String>>

WebViewPermissionType 

PointerLock : 3,


ElementCompositionPreview 

GetContainerVisual(UIElement element) static : Object


GetElementChildVisual(UIElement element) static : Visual


GetElementVisual(UIElement element) static : Visual


GetScrollViewerManipulationPropertySet(ScrollViewer scrollViewer) static : CompositionPropertySet


SetElementChildVisual(UIElement element, Visual visual) static : Void


FontFamily 

XamlAutoFontFamily static { get; } : FontFamily

PartialMediaFailureDetectedEventArgs 

ExtendedError { get; } : Exception




HttpBaseProtocolFilter 

CookieUsageBehavior { get; set; } : HttpCookieUsageBehavior

HttpCookieUsageBehavior 

Default : 0,


NoCookies : 1,