





StartupTask : 1020,


CommandLineLaunch : 1021,



Kind { get; } : ActivationKind


Operation { get; } : CommandLineActivationOperation


PreviousExecutionState { get; } : ApplicationExecutionState


SplashScreen { get; } : SplashScreen


User { get; } : User



Arguments { get; } : String


CurrentDirectoryPath { get; } : String


ExitCode { get; set; } : Int32


GetDeferral() : Deferral


ConsoleActivatedEventArgs



Operation { get; } : CommandLineActivationOperation


IConsoleActivatedEventArgs



TaskId { get; } : String



Kind { get; } : ActivationKind


PreviousExecutionState { get; } : ApplicationExecutionState


SplashScreen { get; } : SplashScreen


TaskId { get; } : String


User { get; } : User




GetChangeTracker(String identity) : AppointmentStoreChangeTracker



IsTracking { get; } : Boolean



AppServiceCallerCapabilityStatus



GetCallerCapabilityStatusAsync(String capabilityName) : IAsyncOperation<AppServiceCallerCapabilityStatus>


CheckCallerForCapabilityAsync(String capabilityName) : IAsyncOperation<Boolean>



PaymentAppCanMakePaymentTrigger



ctor(SmartCardTriggerType triggerType)


TriggerType { get; } : SmartCardTriggerType




SetupNewAcceptedCall(String context, String contactName, String contactNumber, String serviceName, VoipPhoneCallMedia media) : VoipPhoneCall



TryShowAppUI() : Void



CardBuilder


ICardBuilderStatics


ICardElement




IsTracking { get; } : Boolean



GetChangeTracker(String identity) : ContactChangeTracker



GetChangeTracker(String identity) : ContactChangeTracker




AppUserModelId { get; } : String



RestartPending : 0,


NotInForeground : 1,


InvalidUser : 2,


Other : 3,



RequestRestartAsync(String launchArguments) static : IAsyncOperation<AppRestartFailureReason>


RequestRestartAsync(String launchArguments) static : IAsyncOperation<RestartResult>


RequestRestartForUserAsync(User user, String launchArguments) static : IAsyncOperation<AppRestartFailureReason>


RequestRestartForUserAsync(User user, String launchArguments) static : IAsyncOperation<RestartResult>


RestartResult




ShowShareUI(ShareUIOptions options) static : Void


ShowShareUI(ShareUIOptions shareOptions) static : Void


IDataTransferManagerStatics3



InvocationRect { get; set; } : Nullable<Rect>


SelectionRect { get; set; } : Nullable<Rect>


ShareTheme { get; set; } : ShareUITheme


Theme { get; set; } : ShareUITheme




GetChangeTracker(String identity) : EmailMailboxChangeTracker





ReportCanMakePaymentResult(PaymentCanMakePaymentResult value) : Void


Request { get; } : PaymentRequest



ctor(PaymentCanMakePaymentResultStatus value)


Status { get; } : PaymentCanMakePaymentResultStatus



Unknown : 0,


Yes : 1,


No : 2,


NotAllowed : 3,


UserNotSignedIn : 4,


SpecifiedPaymentMethodIdsNotSupported : 5,


NoQualifyingCardOnFile : 6,



CanMakePaymentAsync(PaymentRequest paymentRequest) : IAsyncOperation<Boolean>


CanMakePaymentAsync(PaymentRequest paymentRequest) : IAsyncOperation<PaymentCanMakePaymentResult>



ctor(PaymentDetails details, IEnumerable<PaymentMethodData> methodData, PaymentMerchantInfo merchantInfo, PaymentOptions options, String id)


Id { get; } : String





DeleteUserActivitySessionsInTimeRangeAsync(UserActivityChannel channel, DateTimeOffset startTime, DateTimeOffset endTime) static : IAsyncAction



ToJson() : String



ContentInfo { get; set; } : IUserActivityContentInfo


ContentMetadata { get; set; } : String



AddImageQuery { get; set; } : Boolean


AlternateText { get; set; } : String


ctor()


ctor(Uri iconUri)


IconUri { get; set; } : Uri



FromJson(String value) static : UserActivityContentInfo


ToJson() : String



DeleteActivityAsync(String activityId) : IAsyncAction


DeleteAllActivitiesAsync() : IAsyncAction


GetOrCreateUserActivityAsync(String activityId, HostName host) : IAsyncOperation<UserActivity>



Attribution { get; set; } : UserActivityAttribution


Content { get; set; } : IAdaptiveCard


Content { get; set; } : ICardElement


ImageIcon { get; set; } : Uri



DesignMode2Enabled static { get; } : Boolean



DisabledByPolicy : 3,





CustomGlyphs { get; } : LineDisplayCustomGlyphs


GetAttributes() : LineDisplayAttributes


GetStatisticsAsync(IEnumerable<String> statisticsCategories) : IAsyncOperation<String>


CheckHealthAsync(UnifiedPosHealthCheckLevel level) : IAsyncOperation<String>


CheckPowerStatusAsync() : IAsyncOperation<LineDisplayPowerStatus>


MaxBitmapSizeInPixels { get; } : Size


StatusUpdated event : TypedEventHandler<ClaimedLineDisplay,LineDisplayStatusUpdatedEventArgs>


SupportedCharacterSets { get; } : IReadOnlyList<Int32>


SupportedScreenSizesInCharacters { get; } : IReadOnlyList<Size>


TryClearDescriptorsAsync() : IAsyncOperation<Boolean>


TryCreateWindowAsync(Rect viewport, Size windowSize) : IAsyncOperation<LineDisplayWindow>


TrySetDescriptorAsync(UInt32 descriptor, LineDisplayDescriptorState descriptorState) : IAsyncOperation<Boolean>


TryStoreStorageFileBitmapAsync(StorageFile bitmap) : IAsyncOperation<LineDisplayStoredBitmap>


TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment) : IAsyncOperation<LineDisplayStoredBitmap>


TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, Int32 widthInPixels) : IAsyncOperation<LineDisplayStoredBitmap>


TryUpdateAttributesAsync(LineDisplayAttributes attributes) : IAsyncOperation<Boolean>



CheckPowerStatusAsync() : IAsyncOperation<LineDisplayPowerStatus>


StatisticsCategorySelector static { get; } : LineDisplayStatisticsCategorySelector



BlinkRate { get; set; } : TimeSpan


Brightness { get; set; } : Int32


CurrentWindow { get; set; } : LineDisplayWindow


CharacterSet { get; set; } : Int32


IsCharacterSetMappingEnabled { get; set; } : Boolean


IsPowerNotifyEnabled { get; set; } : Boolean


ScreenSizeInCharacters { get; set; } : Size



CanCustomize { get; } : Boolean


GetAttributes() : LineDisplayCursorAttributes


IsBlinkSupported { get; } : Boolean


IsBlockSupported { get; } : Boolean


IsHalfBlockSupported { get; } : Boolean


IsOtherSupported { get; } : Boolean


IsReverseSupported { get; } : Boolean


IsUnderlineSupported { get; } : Boolean


TryUpdateAttributesAsync(LineDisplayCursorAttributes attributes) : IAsyncOperation<Boolean>



CursorType { get; set; } : LineDisplayCursorType


IsAutoAdvanceEnabled { get; set; } : Boolean


IsBlinkEnabled { get; set; } : Boolean


Position { get; set; } : Point



None : 0,


Block : 1,


HalfBlock : 2,


Underline : 3,


Reverse : 4,


Other : 5,



SizeInPixels { get; } : Size


SupportedGlyphCodes { get; } : IReadOnlyList<UInt32>


TryRedefineAsync(UInt32 glyphCode, IBuffer glyphData) : IAsyncOperation<Boolean>



Off : 0,


On : 1,


Blink : 2,



Left : 0,


Center : 1,


Right : 2,



Format { get; set; } : LineDisplayMarqueeFormat


RepeatWaitInterval { get; set; } : TimeSpan


ScrollWaitInterval { get; set; } : TimeSpan


TryStartScrollingAsync(LineDisplayScrollDirection direction) : IAsyncOperation<Boolean>


TryStopScrollingAsync() : IAsyncOperation<Boolean>



None : 0,


Walk : 1,


Place : 2,



Unknown : 0,


Online : 1,


Off : 2,


Offline : 3,


OffOrOffline : 4,



AllStatistics { get; } : String


ManufacturerStatistics { get; } : String


UnifiedPosStatistics { get; } : String



Status { get; } : LineDisplayPowerStatus



EscapeSequence { get; } : String


TryDeleteAsync() : IAsyncOperation<Boolean>



Top : 0,


Center : 1,


Bottom : 2,



Cursor { get; } : LineDisplayCursor


Marquee { get; } : LineDisplayMarquee


ReadCharacterAtCursorAsync() : IAsyncOperation<UInt32>


TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap) : IAsyncOperation<Boolean>


TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment) : IAsyncOperation<Boolean>


TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, Int32 widthInPixels) : IAsyncOperation<Boolean>


TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels) : IAsyncOperation<Boolean>


TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels, Int32 widthInPixels) : IAsyncOperation<Boolean>


TryDisplayStoredBitmapAtCursorAsync(LineDisplayStoredBitmap bitmap) : IAsyncOperation<Boolean>





MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>



FromIdAsync(String deviceId) static : IAsyncOperation<Accelerometer>


GetDeviceSelector(AccelerometerReadingType readingType) static : String



PerformanceCount { get; } : Nullable<TimeSpan>


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



MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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



FromIdAsync(String deviceId) static : IAsyncOperation<Barometer>


GetDeviceSelector() static : String


MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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



FromIdAsync(String deviceId) static : IAsyncOperation<Compass>


GetDeviceSelector() static : String


MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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



FromIdAsync(String deviceId) static : IAsyncOperation<Gyrometer>


GetDeviceSelector() static : String


MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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



FromIdAsync(String deviceId) static : IAsyncOperation<Inclinometer>


GetDeviceSelector(SensorReadingType readingType) static : String


MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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



FromIdAsync(String deviceId) static : IAsyncOperation<LightSensor>


GetDeviceSelector() static : String


MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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



FromIdAsync(String deviceId) static : IAsyncOperation<Magnetometer>


GetDeviceSelector() static : String


MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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



FromIdAsync(String deviceId) static : IAsyncOperation<OrientationSensor>


GetDeviceSelector(SensorReadingType readingType) static : String


GetDeviceSelector(SensorReadingType readingType, SensorOptimizationGoal optimizationGoal) static : String


MaxBatchSize { get; } : UInt32


ReportLatency { get; set; } : UInt32



PerformanceCount { get; } : Nullable<TimeSpan>


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




Denied : 0,


Allowed : 1,



AppletIds { get; } : IList<IBuffer>


AutomaticEnablement { get; set; } : Boolean


ctor()


ctor(String displayName, IList<IBuffer> appletIds, SmartCardEmulationCategory emulationCategory, SmartCardEmulationType emulationType)


DisplayName { get; set; } : String


MaxAppletIds static { get; } : UInt16


SmartCardEmulationCategory { get; set; } : SmartCardEmulationCategory


SmartCardEmulationType { get; set; } : SmartCardEmulationType



Disabled : 0,


ForegroundOverride : 1,


Enabled : 2,



ActivationPolicy { get; } : SmartCardAppletIdGroupActivationPolicy


AppletIdGroup { get; } : SmartCardAppletIdGroup


Id { get; } : Guid


RequestActivationPolicyChangeAsync(SmartCardAppletIdGroupActivationPolicy policy) : IAsyncOperation<SmartCardActivationPolicyChangeResult>


SetAutomaticResponseApdusAsync(IEnumerable<SmartCardAutomaticResponseApdu> apdus) : IAsyncAction



AllowWhenCryptogramGeneratorNotPrepared { get; set; } : Boolean


AppletId { get; set; } : IBuffer


CommandApdu { get; set; } : IBuffer


CommandApduBitMask { get; set; } : IBuffer


ctor(IBuffer commandApdu, IBuffer responseApdu)


InputState { get; set; } : Nullable<UInt32>


OutputState { get; set; } : Nullable<UInt32>


ResponseApdu { get; set; } : IBuffer


ShouldMatchLength { get; set; } : Boolean



None : 0,


Success : 1,


UnknownError : 2,


SmartCardBackgroundTriggerContract



None : 0,


CbcMac : 1,


Cvc3Umd : 2,


DecimalizedMsd : 3,


Cvc3MD : 4,


Sha1 : 5,


SignedDynamicApplicationData : 6,


RsaPkcs1 : 7,


Sha256Hmac : 8,



CreateCryptogramMaterialStorageKeyAsync(SmartCardUnlockPromptingBehavior promptingBehavior, String storageKeyName, SmartCardCryptogramStorageKeyAlgorithm algorithm, SmartCardCryptogramStorageKeyCapabilities capabilities) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>


DeleteCryptogramMaterialPackageAsync(String materialPackageName) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>


DeleteCryptogramMaterialStorageKeyAsync(String storageKeyName) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>


GetAllCryptogramMaterialCharacteristicsAsync(SmartCardUnlockPromptingBehavior promptingBehavior, String materialPackageName) : IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult>


GetAllCryptogramMaterialPackageCharacteristicsAsync() : IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult>


GetAllCryptogramMaterialPackageCharacteristicsAsync(String storageKeyName) : IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult>


GetAllCryptogramStorageKeyCharacteristicsAsync() : IAsyncOperation<SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult>


GetSmartCardCryptogramGeneratorAsync() static : IAsyncOperation<SmartCardCryptogramGenerator>


ImportCryptogramMaterialPackageAsync(SmartCardCryptogramMaterialPackageFormat format, String storageKeyName, String materialPackageName, IBuffer cryptogramMaterialPackage) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>


IsSupported() static : Boolean


RequestCryptogramMaterialStorageKeyInfoAsync(SmartCardUnlockPromptingBehavior promptingBehavior, String storageKeyName, CryptographicPublicKeyBlobType format) : IAsyncOperation<SmartCardCryptogramStorageKeyInfo>


RequestUnlockCryptogramMaterialForUseAsync(SmartCardUnlockPromptingBehavior promptingBehavior) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>


SupportedCryptogramAlgorithms { get; } : IReadOnlyList<SmartCardCryptogramAlgorithm>


SupportedCryptogramMaterialPackageConfirmationResponseFormats { get; } : IReadOnlyList<SmartCardCryptogramMaterialPackageConfirmationResponseFormat>


SupportedCryptogramMaterialPackageFormats { get; } : IReadOnlyList<SmartCardCryptogramMaterialPackageFormat>


SupportedCryptogramMaterialTypes { get; } : IReadOnlyList<SmartCardCryptogramMaterialType>


SupportedSmartCardCryptogramStorageKeyCapabilities { get; } : IReadOnlyList<SmartCardCryptogramStorageKeyCapabilities>


TryProvePossessionOfCryptogramMaterialPackageAsync(SmartCardUnlockPromptingBehavior promptingBehavior, SmartCardCryptogramMaterialPackageConfirmationResponseFormat responseFormat, String materialPackageName, String materialName, IBuffer challenge) : IAsyncOperation<SmartCardCryptogramMaterialPossessionProof>


ValidateRequestApduAsync(SmartCardUnlockPromptingBehavior promptingBehavior, IBuffer apduToValidate, IEnumerable<SmartCardCryptogramPlacementStep> cryptogramPlacementSteps) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>



Success : 0,


AuthorizationFailed : 1,


AuthorizationCanceled : 2,


AuthorizationRequired : 3,


CryptogramMaterialPackageStorageKeyExists : 4,


NoCryptogramMaterialPackageStorageKey : 5,


NoCryptogramMaterialPackage : 6,


UnsupportedCryptogramMaterialPackage : 7,


UnknownCryptogramMaterialName : 8,


InvalidCryptogramMaterialUsage : 9,


ApduResponseNotSent : 10,


OtherError : 11,


ValidationFailed : 12,


NotSupported : 13,



Characteristics { get; } : IReadOnlyList<SmartCardCryptogramMaterialCharacteristics>


OperationStatus { get; } : SmartCardCryptogramGeneratorOperationStatus



Characteristics { get; } : IReadOnlyList<SmartCardCryptogramMaterialPackageCharacteristics>


OperationStatus { get; } : SmartCardCryptogramGeneratorOperationStatus



Characteristics { get; } : IReadOnlyList<SmartCardCryptogramStorageKeyCharacteristics>


OperationStatus { get; } : SmartCardCryptogramGeneratorOperationStatus



AllowedAlgorithms { get; } : IReadOnlyList<SmartCardCryptogramAlgorithm>


AllowedProofOfPossessionAlgorithms { get; } : IReadOnlyList<SmartCardCryptogramMaterialPackageConfirmationResponseFormat>


AllowedValidations { get; } : IReadOnlyList<SmartCardCryptogramAlgorithm>


MaterialLength { get; } : Int32


MaterialName { get; } : String


MaterialType { get; } : SmartCardCryptogramMaterialType


ProtectionMethod { get; } : SmartCardCryptogramMaterialProtectionMethod


ProtectionVersion { get; } : Int32



None : 0,


VisaHmac : 1,



None : 0,


JweRsaPki : 1,



DateImported { get; } : DateTimeOffset


PackageFormat { get; } : SmartCardCryptogramMaterialPackageFormat


PackageName { get; } : String


StorageKeyName { get; } : String



OperationStatus { get; } : SmartCardCryptogramGeneratorOperationStatus


Proof { get; } : IBuffer



None : 0,


WhiteBoxing : 1,



None : 0,


StaticDataAuthentication : 1,


TripleDes112 : 2,


Aes : 3,


RsaPkcs1 : 4,



None : 0,


UnitsAreInNibbles : 1,


ChainOutput : 2,



Algorithm { get; set; } : SmartCardCryptogramAlgorithm


CryptogramLength { get; set; } : Int32


CryptogramMaterialName { get; set; } : String


CryptogramMaterialPackageName { get; set; } : String


CryptogramOffset { get; set; } : Int32


CryptogramPlacementOptions { get; set; } : SmartCardCryptogramPlacementOptions


ChainedOutputStep { get; set; } : SmartCardCryptogramPlacementStep


SourceData { get; set; } : IBuffer


TemplateOffset { get; set; } : Int32



None : 0,


Rsa2048 : 1,



None : 0,


HardwareProtection : 1,


UnlockPrompt : 2,



Algorithm { get; } : SmartCardCryptogramStorageKeyAlgorithm


Capabilities { get; } : SmartCardCryptogramStorageKeyCapabilities


DateCreated { get; } : DateTimeOffset


StorageKeyName { get; } : String



Attestation { get; } : IBuffer


AttestationCertificateChain { get; } : IBuffer


AttestationStatus { get; } : SmartCardCryptographicKeyAttestationStatus


Capabilities { get; } : SmartCardCryptogramStorageKeyCapabilities


OperationalRequirements { get; } : String


OperationStatus { get; } : SmartCardCryptogramGeneratorOperationStatus


PublicKey { get; } : IBuffer


PublicKeyBlobType { get; } : CryptographicPublicKeyBlobType



NoAttestation : 0,


SoftwareKeyWithoutTpm : 1,


SoftwareKeyWithTpm : 2,


TpmKeyUnknownAttestationStatus : 3,


TpmKeyWithoutAttestationCapability : 4,


TpmKeyWithTemporaryAttestationFailure : 5,


TpmKeyWithLongTermAttestationFailure : 6,


TpmKeyWithAttestation : 7,



Other : 0,


Payment : 1,



Host : 0,


Uicc : 1,


EmbeddedSE : 2,



ApduReceived event : TypedEventHandler<SmartCardEmulator,SmartCardEmulatorApduReceivedEventArgs>


ConnectionDeactivated event : TypedEventHandler<SmartCardEmulator,SmartCardEmulatorConnectionDeactivatedEventArgs>


EnablementPolicy { get; } : SmartCardEmulatorEnablementPolicy


GetAppletIdGroupRegistrationsAsync() static : IAsyncOperation<IReadOnlyList<SmartCardAppletIdGroupRegistration>>


GetDefaultAsync() static : IAsyncOperation<SmartCardEmulator>


IsHostCardEmulationSupported() : Boolean


IsSupported() static : Boolean


MaxAppletIdGroupRegistrations static { get; } : UInt16


RegisterAppletIdGroupAsync(SmartCardAppletIdGroup appletIdGroup) static : IAsyncOperation<SmartCardAppletIdGroupRegistration>


Start() : Void


UnregisterAppletIdGroupAsync(SmartCardAppletIdGroupRegistration registration) static : IAsyncAction



AutomaticResponseStatus { get; } : SmartCardAutomaticResponseStatus


CommandApdu { get; } : IBuffer


ConnectionProperties { get; } : SmartCardEmulatorConnectionProperties


State { get; } : UInt32


TryRespondAsync(IBuffer responseApdu) : IAsyncOperation<Boolean>


TryRespondAsync(IBuffer responseApdu, Nullable<UInt32> nextState) : IAsyncOperation<Boolean>


TryRespondWithCryptogramsAsync(IBuffer responseTemplate, IEnumerable<SmartCardCryptogramPlacementStep> cryptogramPlacementSteps) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>


TryRespondWithCryptogramsAsync(IBuffer responseTemplate, IEnumerable<SmartCardCryptogramPlacementStep> cryptogramPlacementSteps, Nullable<UInt32> nextState) : IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus>



ConnectionProperties { get; } : SmartCardEmulatorConnectionProperties


Reason { get; } : SmartCardEmulatorConnectionDeactivatedReason



ConnectionLost : 0,


ConnectionRedirected : 1,



Id { get; } : Guid


Source { get; } : SmartCardEmulatorConnectionSource



Unknown : 0,


NfcReader : 1,


SmartCardEmulatorContract



Never : 0,


Always : 1,


ScreenOn : 2,


ScreenUnlocked : 3,



Default : 0,


AboveLock : 1,



Emulator { get; } : SmartCardEmulator


SmartCard { get; } : SmartCard


SourceAppletId { get; } : IBuffer


TriggerData { get; } : IBuffer


TriggerType { get; } : SmartCardTriggerType


TryLaunchCurrentAppAsync(String arguments) : IAsyncOperation<Boolean>


TryLaunchCurrentAppAsync(String arguments, SmartCardLaunchBehavior behavior) : IAsyncOperation<Boolean>



EmulatorTransaction : 0,


EmulatorNearFieldEntry : 1,


EmulatorNearFieldExit : 2,


EmulatorHostApplicationActivated : 3,


EmulatorAppletIdGroupRegistrationChanged : 4,


ReaderCardAdded : 5,



AllowUnlockPrompt : 0,


RequireUnlockPrompt : 1,


PreventUnlockPrompt : 2,




ConnectAsync(WiFiAvailableNetwork availableNetwork, WiFiReconnectionKind reconnectionKind, PasswordCredential passwordCredential, String ssid, WiFiConnectionMethod connectionMethod) : IAsyncOperation<WiFiConnectionResult>


GetWpsConfigurationAsync(WiFiAvailableNetwork availableNetwork) : IAsyncOperation<WiFiWpsConfigurationResult>



Default : 0,


WpsPin : 1,


WpsPushButton : 2,



Status { get; } : WiFiWpsConfigurationStatus


SupportedWpsKinds { get; } : IReadOnlyList<WiFiWpsKind>



UnspecifiedFailure : 0,


Success : 1,


Timeout : 2,



Unknown : 0,


Pin : 1,


PushButton : 2,


Nfc : 3,


Ethernet : 4,


Usb : 5,






MergeEntriesAsync(GameListEntry left, GameListEntry right) static : IAsyncOperation<GameListEntry>


UnmergeEntryAsync(GameListEntry mergedEntry) static : IAsyncOperation<IReadOnlyList<GameListEntry>>



GameModeConfiguration { get; } : GameModeConfiguration


LaunchableState { get; } : GameListEntryLaunchableState


LauncherExecutable { get; } : IStorageFile


LaunchParameters { get; } : String


SetLauncherExecutableFileAsync(IStorageFile executableFile) : IAsyncAction


SetLauncherExecutableFileAsync(IStorageFile executableFile, String launchParams) : IAsyncAction


SetTitleIdAsync(String id) : IAsyncAction


TitleId { get; } : String



NotLaunchable : 0,


ByLastRunningFullPath : 1,


ByUserProvidedPath : 2,


ByTile : 3,



AffinitizeToExclusiveCpus { get; set; } : Boolean


CpuExclusivityMaskHigh { get; set; } : Nullable<Int32>


CpuExclusivityMaskLow { get; set; } : Nullable<Int32>


IsEnabled { get; set; } : Boolean


MaxCpuCount { get; set; } : Nullable<Int32>


PercentGpuMemoryAllocatedToGame { get; set; } : Nullable<Int32>


PercentGpuMemoryAllocatedToSystemCompositor { get; set; } : Nullable<Int32>


PercentGpuTimeAllocatedToGame { get; set; } : Nullable<Int32>


RelatedProcessNames { get; } : IList<String>


SaveAsync() : IAsyncAction



GamingRelatedProcessNames { get; } : IList<String>


GetDefault() static : GameModeUserConfiguration


SaveAsync() : IAsyncAction




GetDefault() static : GameMonitor


RequestPermissionAsync() : IAsyncOperation<GameMonitoringPermission>



Allowed : 0,


DeniedByUser : 1,


DeniedBySystem : 2,



GameUIArgs { get; } : ValueSet


Kind { get; } : ActivationKind


PreviousExecutionState { get; } : ApplicationExecutionState


ReportCompleted(ValueSet results) : Void


SplashScreen { get; } : SplashScreen


GamingUIProviderContract





CreateLayerConfig() : PresentationLayerConfig


DrmMode { get; set; } : PresentationLayerDrmMode


GetPresentationLayers() : PresentationLayers


SetLayerConfig(PresentationLayerConfig layerConfig) : Void



GetPresentationLayerRenderingParameters(PresentationLayerQuad layer) : PresentationLayerRenderingParametersQuad



RefreshRate { get; } : Double



IsConfigured static { get; } : Boolean



PresentationLayerSettings { get; } : IReadOnlyList<PresentationLayerSettings>



Disable : 0,


SoftwareEncryption : 1,



DrmMode { get; set; } : PresentationLayerDrmMode


ReprojectionMode { get; set; } : HolographicReprojectionMode


TextureDesc { get; set; } : Direct3DSurfaceDescription



Quad { get; } : PresentationLayerQuad


Type { get; } : PresentationLayerType



Direct3D11ContentBuffer { get; } : IDirect3DSurface


DrmMode { get; } : PresentationLayerDrmMode


SetQuadPlaneParameters(SpatialCoordinateSystem positionedAndOrientedCoordinateSystem, Vector2 extents) : Void



Layers { get; } : IReadOnlyList<PresentationLayerReference>



Enabled { get; set; } : Boolean


Type { get; } : PresentationLayerType



World : 0,


Quad : 1,





SessionId { get; } : String


SourceAppDisplayName { get; } : String


SourceApplicationExecutableName { get; } : String





None : 0,


InstallAllResources : 32,


ForceTargetAppShutdown : 64,


RequiredContentGroupOnly : 256,



AddPackageAsync(Uri packageUri, IEnumerable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IEnumerable<String> optionalPackageFamilyNames, IEnumerable<Uri> packageUrisToInstall, IEnumerable<Uri> relatedPackageUris) : IAsyncOperationWithProgress<DeploymentResult,DeploymentProgress>


AddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume) : IAsyncOperationWithProgress<DeploymentResult,DeploymentProgress>


ProvisionPackageForAllUsersAsync(String packageFamilyName) : IAsyncOperationWithProgress<DeploymentResult,DeploymentProgress>


RequestAddPackageAsync(Uri packageUri, IEnumerable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IEnumerable<String> optionalPackageFamilyNames, IEnumerable<Uri> relatedPackageUris) : IAsyncOperationWithProgress<DeploymentResult,DeploymentProgress>


RequestAddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume) : IAsyncOperationWithProgress<DeploymentResult,DeploymentProgress>


StagePackageAsync(Uri packageUri, IEnumerable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IEnumerable<String> optionalPackageFamilyNames, IEnumerable<Uri> packageUrisToInstall, IEnumerable<Uri> relatedPackageUris) : IAsyncOperationWithProgress<DeploymentResult,DeploymentProgress>




AppBroadcastingContract



IsCurrentAppBroadcasting { get; } : Boolean


IsCurrentAppBroadcastingChanged event : TypedEventHandler<AppBroadcastingMonitor,Object>



CanStartBroadcast { get; } : Boolean


Details { get; } : AppBroadcastingStatusDetails



IsAnyAppBroadcasting { get; } : Boolean


IsAppInactive { get; } : Boolean


IsBlockedForApp { get; } : Boolean


IsCaptureResourceUnavailable { get; } : Boolean


IsDisabledBySystem { get; } : Boolean


IsDisabledByUser { get; } : Boolean


IsGameStreamInProgress { get; } : Boolean


IsGpuConstrained { get; } : Boolean



GetDefault() static : AppBroadcastingUI


GetForUser(User user) static : AppBroadcastingUI


GetStatus() : AppBroadcastingStatus


ShowBroadcastUI() : Void



AppRecordingContract



GetDefault() static : AppRecordingManager


GetStatus() : AppRecordingStatus


RecordTimeSpanToFileAsync(DateTimeOffset startTime, TimeSpan duration, StorageFile file) : IAsyncOperation<AppRecordingResult>


SaveScreenshotToFilesAsync(StorageFolder folder, String filenamePrefix, AppRecordingSaveScreenshotOption option, IEnumerable<String> requestedFormats) : IAsyncOperation<AppRecordingSaveScreenshotResult>


StartRecordingToFileAsync(StorageFile file) : IAsyncOperation<AppRecordingResult>


SupportedScreenshotMediaEncodingSubtypes { get; } : IReadOnlyList<String>



Duration { get; } : TimeSpan


ExtendedError { get; } : Exception


IsFileTruncated { get; } : Boolean


Succeeded { get; } : Boolean



File { get; } : StorageFile


MediaEncodingSubtype { get; } : String



None : 0,


HdrContentVisible : 1,



ExtendedError { get; } : Exception


SavedScreenshotInfos { get; } : IReadOnlyList<AppRecordingSavedScreenshotInfo>


Succeeded { get; } : Boolean



CanRecord { get; } : Boolean


CanRecordTimeSpan { get; } : Boolean


Details { get; } : AppRecordingStatusDetails


HistoricalBufferDuration { get; } : TimeSpan



IsAnyAppBroadcasting { get; } : Boolean


IsAppInactive { get; } : Boolean


IsBlockedForApp { get; } : Boolean


IsCaptureResourceUnavailable { get; } : Boolean


IsDisabledBySystem { get; } : Boolean


IsDisabledByUser { get; } : Boolean


IsGameStreamInProgress { get; } : Boolean


IsGpuConstrained { get; } : Boolean


IsTimeSpanRecordingDisabled { get; } : Boolean




BroadcastChannel { get; set; } : String


BroadcastChannelChanged event : TypedEventHandler<AppBroadcastBackgroundService,Object>


BroadcastLanguage { get; set; } : String


BroadcastLanguageChanged event : TypedEventHandler<AppBroadcastBackgroundService,Object>


BroadcastTitle { get; } : String


BroadcastTitle { get; set; } : String


BroadcastTitleChanged event : TypedEventHandler<AppBroadcastBackgroundService,Object>



UserNameChanged event : TypedEventHandler<AppBroadcastBackgroundServiceSignInInfo,Object>



ReportProblemWithStream() : Void



SetAllowedAsync(Boolean allowed) static : IAsyncAction


AppCaptureMetadataContract



Informational : 0,


Important : 1,



AddDoubleEvent(String name, Double value, AppCaptureMetadataPriority priority) : Void


AddInt32Event(String name, Int32 value, AppCaptureMetadataPriority priority) : Void


AddStringEvent(String name, String value, AppCaptureMetadataPriority priority) : Void


Dispose() : Void


MetadataPurged event : TypedEventHandler<AppCaptureMetadataWriter,Object>


RemainingStorageBytesAvailable { get; } : UInt64


StartDoubleState(String name, Double value, AppCaptureMetadataPriority priority) : Void


StartInt32State(String name, Int32 value, AppCaptureMetadataPriority priority) : Void


StartStringState(String name, String value, AppCaptureMetadataPriority priority) : Void


StopAllStates() : Void


StopState(String name) : Void




FuseAsync(IEnumerable<SoftwareBitmap> frameSet) static : IAsyncOperationWithProgress<LowLightFusionResult,Double>


MaxSupportedFrameCount static { get; } : Int32


SupportedBitmapPixelFormats static { get; } : IReadOnlyList<BitmapPixelFormat>



Dispose() : Void


Frame { get; } : SoftwareBitmap



CreateFromDownloadOperation(DownloadOperation downloadOperation) static : MediaSource


CreateFromMediaFrameSource(MediaFrameSource frameSource) static : MediaSource



AnalysisRecommendation { get; } : SceneAnalysisRecommendation



Standard : 0,


Hdr : 1,


LowLight : 2,




Current static { get; } : DialReceiverApp


GetAdditionalDataAsync() : IAsyncOperation<IDictionary<String,String>>


SetAdditionalDataAsync(IEnumerable<KeyValuePair<String,String>> additionalData) : IAsyncAction





Length : UInt64


Offset : UInt64



AddedRanges { get; } : IList<BackgroundTransferFileRange>


GetDeferral() : Deferral


WasDownloadRestarted { get; } : Boolean



PausedRecoverableWebErrorStatus : 8,



CurrentWebErrorStatus { get; } : Nullable<WebErrorStatus>


GetDownloadedRanges() : IList<BackgroundTransferFileRange>


GetResultRandomAccessStreamReference() : IRandomAccessStreamReference


IsRandomAccessRequired { get; set; } : Boolean


RangesDownloaded event : TypedEventHandler<DownloadOperation,BackgroundTransferRangesDownloadedEventArgs>


RecoverableWebErrorStatuses { get; } : IList<WebErrorStatus>


RequestedUri { get; } : Uri


RequestedUri { get; set; } : Uri




GetProviderNetworkUsageAsync(DateTimeOffset startTime, DateTimeOffset endTime, NetworkUsageStates states) : IAsyncOperation<IReadOnlyList<ProviderNetworkUsage>>



BytesReceived { get; } : UInt64


BytesSent { get; } : UInt64


ProviderId { get; } : String




AntennaIndex { get; } : Int32


SarBackoffIndex { get; } : Int32



GetIsPassthroughEnabledAsync() : IAsyncOperation<Boolean>


SetIsPassthroughEnabledAsync(Boolean value) : IAsyncOperation<MobileBroadbandModemStatus>



GetSarManagerAsync() : IAsyncOperation<MobileBroadbandSarManager>



Success : 0,


OtherFailure : 1,


Busy : 2,


NoDeviceSupport : 3,



AntennaConfiguration { get; } : IReadOnlyList<MobileBroadbandAntenna>


ConfigureHysteresisTimerAsync(TimeSpan hysteresis) : IAsyncAction


ConfigureSarAsync(Boolean backoffEnabled, IEnumerable<MobileBroadbandAntenna> antennas) : IAsyncAction


HysteresisTimer { get; } : TimeSpan


IsBackoffEnabled { get; } : Boolean


IsSarControlledByHardware { get; } : Boolean


IsWiFiHardwareIntegrated { get; } : Boolean


QueryTransmissionStateAsync() : IAsyncOperation<Boolean>


RevertSarToHardwareControlAsync() : IAsyncAction


TransmissionStateChanged event : TypedEventHandler<MobileBroadbandSarManager,MobileBroadbandTransmissionStateChangedEventArgs>



HysteresisTimer { get; } : TimeSpan


IsTransmissionStateActive { get; } : Boolean




ActualUnsolicitedPongInterval { get; } : TimeSpan


ClientCertificate { get; set; } : Certificate


DesiredUnsolicitedPongInterval { get; set; } : TimeSpan


ReceiveMode { get; set; } : MessageWebSocketReceiveMode



IsMessageComplete { get; } : Boolean



FullMessage : 0,


PartialMessage : 1,



Unspecified : 9,



MinProtectionLevel { get; set; } : SocketProtectionLevel



ActualUnsolicitedPongInterval { get; } : TimeSpan


ClientCertificate { get; set; } : Certificate


DesiredUnsolicitedPongInterval { get; set; } : TimeSpan





IsProtectWhileOpenSupported { get; } : Boolean






IsScenic { get; } : Boolean




CreateFromLocalLocation(LocalLocation location) static : PlaceInfo



IsScenic { get; } : Boolean



Scenic : 3,



Create(Geopoint referencePoint) static : PlaceInfo


Create(Geopoint referencePoint, PlaceInfoCreateOptions options) static : PlaceInfo


CreateFromIdentifier(String identifier) static : PlaceInfo


CreateFromIdentifier(String identifier, Geopoint defaultPoint, PlaceInfoCreateOptions options) static : PlaceInfo


CreateFromMapLocation(MapLocation location) static : PlaceInfo


DisplayAddress { get; } : String


DisplayName { get; } : String


Geoshape { get; } : IGeoshape


Identifier { get; } : String


IsShowSupported static { get; } : Boolean


Show(Rect selection) : Void


Show(Rect selection, Placement preferredPlacement) : Void



DisplayAddress { get; set; } : String


DisplayName { get; set; } : String





SetItemCustomPropertiesAsync(IStorageItem item, IEnumerable<StorageItemCustomProperty> states) static : IAsyncAction



IconReference { get; set; } : String


Id { get; set; } : UInt32


Value { get; set; } : String



CloudFilesContract



DisplayName : String


DisplayName { get; set; } : String


StateID : Int32


StateId { get; set; } : Int32



GetCustomProperties(String itemPath) : IEnumerable<StorageItemCustomProperty>



IsPropertySupported(String propertyCanonicalName) : Boolean



Id { get; set; } : String


ID { get; set; } : String


Path { get; set; } : IStorageFolder


Path { get; set; } : String



CurrentSyncRoots { get; } : IReadOnlyList<SyncRootInformation>


GetCurrentSyncRoots() static : IReadOnlyList<SyncRootInformation>


GetSyncRootInformationFromId(String id) : SyncRootInformation


GetSyncRootInformationFromId(String id) static : SyncRootInformation


GetSyncRootInformationFromPath(String path) : SyncRootInformation


GetSyncRootInformationFromPath(String path) static : SyncRootInformation


Register(SyncRootInformation syncRootInformation) : Void


Register(SyncRootInformation syncRootInformation) static : Void


Unregister(SyncRootInformation syncRootInformation) : Void


Unregister(SyncRootInformation syncRootInformation) static : Void




OnlyUseIndexerAndOptimizeForIndexedProperties : 3,



IsPropertySupportedForPartialFileAsync(String propertyCanonicalName) : IAsyncOperation<Boolean>





GetAppDiagnosticInfos() : IList<AppDiagnosticInfo>


TryGetAppDiagnosticInfo() : IList<AppDiagnosticInfo>




Registry : 3,




ManufacturerDisplayName { get; } : String


ModelDisplayName { get; } : String



Iot static { get; } : String


Laptop static { get; } : String


Tablet static { get; } : String



CreateResourceGroupWatcher() : AppResourceGroupInfoWatcher


CreateResourceGroupWatcher() : ResourceGroupInfoWatcher


GetResourceGroups() : IList<AppResourceGroupInfo>


GetResourceGroups() : IList<ResourceGroupInfo>


RequestAccessAsync() static : IAsyncOperation<DiagnosticAccessStatus>


RequestInfoForAppAsync() static : IAsyncOperation<IList<AppDiagnosticInfo>>


RequestInfoForAppAsync(String appUserModelId) static : IAsyncOperation<IList<AppDiagnosticInfo>>


RequestInfoForAppAsync(String aumid) static : IAsyncOperation<IList<AppDiagnosticInfo>>


RequestPermissionAsync() static : IAsyncOperation<DiagnosticPermission>



EntryPoint { get; } : String


Name { get; } : String


TaskId { get; } : Guid


Trigger { get; } : String



Unknown : 0,


Over : 1,


Under : 2,



Unknown : 0,


Running : 1,


Suspending : 2,


Suspended : 3,


NotRunning : 4,



GetBackgroundTaskReports() : IList<AppResourceGroupBackgroundTaskReport>


GetMemoryReport() : AppResourceGroupMemoryReport


GetProcessDiagnosticInfos() : IList<ProcessDiagnosticInfo>


GetStateReport() : AppResourceGroupStateReport


InstanceId { get; } : Guid


IsShared { get; } : Boolean



Added event : TypedEventHandler<AppResourceGroupInfoWatcher,AppResourceGroupInfoWatcherEventArgs>


EnumerationCompleted event : TypedEventHandler<AppResourceGroupInfoWatcher,Object>


ExecutionStateChanged event : TypedEventHandler<AppResourceGroupInfoWatcher,AppResourceGroupInfoWatcherExecutionStateChangedEventArgs>


Removed event : TypedEventHandler<AppResourceGroupInfoWatcher,AppResourceGroupInfoWatcherEventArgs>


Start() : Void


Status { get; } : AppResourceGroupInfoWatcherStatus


Stop() : Void


Stopped event : TypedEventHandler<AppResourceGroupInfoWatcher,Object>



AppDiagnosticInfos { get; } : IReadOnlyList<AppDiagnosticInfo>


AppResourceGroupInfo { get; } : AppResourceGroupInfo



AppDiagnosticInfos { get; } : IReadOnlyList<AppDiagnosticInfo>


AppResourceGroupInfo { get; } : AppResourceGroupInfo



Created : 0,


Started : 1,


EnumerationCompleted : 2,


Stopping : 3,


Stopped : 4,


Aborted : 5,



CommitUsageLevel { get; } : AppMemoryUsageLevel


CommitUsageLimit { get; } : UInt64


PrivateCommitUsage { get; } : UInt64


TotalCommitUsage { get; } : UInt64



EnergyQuotaState { get; } : AppResourceGroupEnergyQuotaState


ExecutionState { get; } : AppResourceGroupExecutionState


BackgroundTaskReport



SetSystemDateTime(DateTimeOffset utcDateTime) static : Void



Unspecified : 0,


Denied : 1,


Limited : 2,


Allowed : 3,


DiagnosticPermission



ShutdownCompleted event : TypedEventHandler<DispatcherQueue,Object>


ShutdownStarting event : TypedEventHandler<DispatcherQueue,DispatcherQueueShutdownStartingEventArgs>



CreateOnDedicatedThread() static : DispatcherQueueController


CreateQueueWithDedicatedThread() static : DispatcherQueueController


QueueShutdown event : TypedEventHandler<DispatcherQueueController,Object>



GetDeferral() : Deferral



IsRunning { get; } : Boolean


IsStarted { get; } : Boolean


EnergyQuotaState


ExecutionState


MemoryReport


ResourceGroupInfo


ResourceGroupInfoWatcher


ResourceGroupInfoWatcherEventArgs


ResourceGroupInfoWatcherExecutionStateChangedEventArgs


ResourceGroupInfoWatcherStatus


StateReport






BrdfType { get; set; } : SceneLightingEffectBrdfType


ReflectanceModel { get; set; } : SceneLightingEffectReflectanceModel


SceneLightingEffectBrdfType



BlinnPhong : 0,


PhysicallyBasedBlinnPhong : 1,




ConfigureVector2PositionInertiaModifiers(IEnumerable<InteractionTrackerVector2InertiaModifier> modifiers) : Void



Condition { get; set; } : ExpressionAnimation


Create(Compositor compositor) static : InteractionTrackerInertiaNaturalMotion


NaturalMotion { get; set; } : ScalarNaturalMotionAnimation


InteractionTrackerVector2InertiaModifier



Condition { get; set; } : ExpressionAnimation


Create(Compositor compositor) static : InteractionTrackerVector2InertiaNaturalMotion


NaturalMotion { get; set; } : Vector2NaturalMotionAnimation


CompositionAnchor



ExpressionProperties { get; } : ExpressionProperties


InitialValueExpressions { get; } : InitialValueExpressions



Color { get; set; } : Color


Offset { get; set; } : Single



Size { get; } : UInt32



HslLinear : 3,


RgbLinear : 4,



AnchorPoint { get; set; } : Vector2


CenterPoint { get; set; } : Vector2


ColorStops { get; } : CompositionColorGradientStopCollection


ExtendMode { get; set; } : CompositionGradientExtendMode


InterpolationSpace { get; set; } : CompositionColorSpace


Offset { get; set; } : Vector2


RotationAngle { get; set; } : Single


RotationAngleInDegrees { get; set; } : Single


Scale { get; set; } : Vector2


TransformMatrix { get; set; } : Matrix3x2



Clamp : 0,


Wrap : 1,


Mirror : 2,


CompositionIsland


CompositionIslandEventArgs


CompositionIslandVisibilityHints



Exclusions { get; } : VisualUnorderedCollection


ExclusionsFromTargets { get; } : VisualUnorderedCollection



EndPoint { get; set; } : Vector2


StartPoint { get; set; } : Vector2



DispatcherQueue { get; } : DispatcherQueue



CreateColorGradientStop() : CompositionColorGradientStop


CreateColorGradientStop(Single offset, Color color) : CompositionColorGradientStop


CreateLinearGradientBrush() : CompositionLinearGradientBrush


CreateSpringScalarAnimation() : SpringScalarNaturalMotionAnimation


CreateSpringVector2Animation() : SpringVector2NaturalMotionAnimation


CreateSpringVector3Animation() : SpringVector3NaturalMotionAnimation


CreateVisualIslandSite() : VisualIslandSite


CreateVisualTreeIsland() : VisualTreeIsland


ExpressionProperties


FramedIslandSite


HwndIslandSite


ICompositionIslandSite



Size { get; } : UInt32


IVisual3



Shadow { get; set; } : CompositionShadow



DelayBehavior { get; set; } : AnimationDelayBehavior


DelayTime { get; set; } : TimeSpan


StopBehavior { get; set; } : AnimationStopBehavior


PopupIslandSite



FinalValue { get; set; } : Nullable<Single>


InitialValue { get; set; } : Nullable<Single>


InitialVelocity { get; set; } : Single



DampingRatio { get; set; } : Single


Period { get; set; } : TimeSpan



DampingRatio { get; set; } : Single


Period { get; set; } : TimeSpan



DampingRatio { get; set; } : Single


Period { get; set; } : TimeSpan



FinalValue { get; set; } : Nullable<Vector2>


InitialValue { get; set; } : Nullable<Vector2>


InitialVelocity { get; set; } : Vector2



FinalValue { get; set; } : Nullable<Vector3>


InitialValue { get; set; } : Nullable<Vector3>


InitialVelocity { get; set; } : Vector3



CreateAnchor() : CompositionAnchor


VisualIslandSite


VisualIslandSiteEventArgs


VisualTreeIsland




Pin : 14,


Person : 15,



ActivationMode { get; } : CoreWindowActivationMode



None : 0,


Deactivated : 1,


ActivatedNotForeground : 2,


ActivatedInForeground : 3,






AppendInkPoints(IEnumerable<InkPoint> inkPoints) : Rect


BoundingRect { get; } : Rect


CreateInkStroke() : InkStroke


ctor(InkDrawingAttributes drawingAttributes, Matrix3x2 pointTransform)


DrawingAttributes { get; } : InkDrawingAttributes


PointTransform { get; } : Matrix3x2



InkPresenter { get; } : InkPresenter


RootVisual { get; set; } : ContainerVisual





Buttons { get; set; } : GamepadButtons


ctor()


ctor(GamepadReading reading)


LeftThumbstickX { get; set; } : Double


LeftThumbstickY { get; set; } : Double


LeftTrigger { get; set; } : Double


RightThumbstickX { get; set; } : Double


RightThumbstickY { get; set; } : Double


RightTrigger { get; set; } : Double



InitializeGamepadInjection() : Void


InjectGamepadInput(InjectedInputGamepadInfo input) : Void


TryCreateForAppBroadcastOnly() static : InputInjector


UninitializeGamepadInjection() : Void




TryGetRenderableModelAsync() : IAsyncOperation<IRandomAccessStreamWithContentType>



Both : 3,



AngularVelocity { get; } : Nullable<Vector3>


PositionQuality { get; } : SpatialInteractionSourcePositionQuality


SourcePointerPose { get; } : SpatialPointerInteractionSourcePose



Tracked : 0,


Inferred : 1,


LastKnownPosition : 2,



Orientation { get; } : Quaternion


PositionQuality { get; } : SpatialInteractionSourcePositionQuality



AppController static { get; set; } : RadialController


IsAppControllerEnabled static { get; set; } : Boolean




CreateAdaptiveCardFromJson(String value) static : IAdaptiveCard



ToJson() : String



CreateAdaptiveCardFromJson(String value) : IAdaptiveCard



GetDefault() static : TaskbarManager


IsAppListEntryPinnedAsync(AppListEntry appListEntry) : IAsyncOperation<Boolean>


IsCurrentAppPinnedAsync() : IAsyncOperation<Boolean>


IsPinningAllowed { get; } : Boolean


IsSupported { get; } : Boolean


RequestPinAppListEntryAsync(AppListEntry appListEntry) : IAsyncOperation<Boolean>


RequestPinCurrentAppAsync() : IAsyncOperation<Boolean>




MixedRealityModel { get; } : TileMixedRealityModel



BoundingBox { get; set; } : Nullable<SpatialBoundingBox>


Uri { get; set; } : Uri



TaskbarManager





GetCoreInputViewOcclusions() : IReadOnlyList<CoreInputViewOcclusion>


GetForCurrentView() static : CoreInputView


OcclusionsChanged event : TypedEventHandler<CoreInputView,CoreInputViewOcclusionsChangedEventArgs>


TryHidePrimaryView() : Boolean


TryShowPrimaryView() : Boolean



OccludingRect { get; } : Rect


OcclusionKind { get; } : CoreInputViewOcclusionKind



Docked : 0,


Floating : 1,


Overlay : 2,



Handled { get; set; } : Boolean


Occlusions { get; } : IReadOnlyList<CoreInputViewOcclusion>


CoreInputView


CoreInputViewFrameworkOccludingInputViewsChangedEventArgs


CoreInputViewOccludingInputViewsChangedEventArgs


CoreOccludingInputView


CoreOccludingInputViews


CoreOccludingInputViewType



CustomMaxSize { get; set; } : Size


CustomMinSize { get; set; } : Size




RequestRestartAsync(String launchArguments) static : IAsyncOperation<AppRestartFailureReason>


RequestRestartForUserAsync(User user, String launchArguments) static : IAsyncOperation<AppRestartFailureReason>



ActivatedOperation { get; } : ActivatedOperation


Kind { get; } : ActivationKind


Operation { get; } : CommandLineActivationOperation


PreviousExecutionState { get; } : ApplicationExecutionState


SplashScreen { get; } : SplashScreen


User { get; } : User


WebUIConsoleActivatedEventArgs



Kind { get; } : ActivationKind


PreviousExecutionState { get; } : ApplicationExecutionState


SplashScreen { get; } : SplashScreen


TaskId { get; } : String


User { get; } : User






ItemAdded : 0,


ItemRemoved : 1,


ActionCompleted : 2,


ActionAborted : 3,


Other : 4,



ImportantAll : 0,


ImportantMostRecent : 1,


All : 2,


MostRecent : 3,


CurrentThenMostRecent : 4,



RaiseNotificationEvent(AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, String displayString, String activityId) : Void





Layers { get; set; } : IList<MapLayer>


LayersProperty static { get; } : DependencyProperty


TryGetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, Geopoint& location) : Boolean


TryGetLocationFromOffset(Point offset, Geopoint& location) : Boolean



CreateMapControl(Boolean rasterRenderMode) static : MapControl



MapStyleSheetEntry { get; set; } : String


MapStyleSheetEntryProperty static { get; } : DependencyProperty


MapStyleSheetEntryState { get; set; } : String


MapStyleSheetEntryStateProperty static { get; } : DependencyProperty


Tag { get; set; } : Object


TagProperty static { get; } : DependencyProperty



Heading { get; set; } : Double


HeadingProperty static { get; } : DependencyProperty


Location { get; set; } : Geopoint


LocationProperty static { get; } : DependencyProperty


Model { get; set; } : MapModel3D


Pitch { get; set; } : Double


PitchProperty static { get; } : DependencyProperty


Roll { get; set; } : Double


RollProperty static { get; } : DependencyProperty


Scale { get; set; } : Vector3


ScaleProperty static { get; } : DependencyProperty



MapContextRequested event : TypedEventHandler<MapElementsLayer,MapElementsLayerContextRequestedEventArgs>


MapElementClick event : TypedEventHandler<MapElementsLayer,MapElementsLayerClickEventArgs>


MapElementPointerEntered event : TypedEventHandler<MapElementsLayer,MapElementsLayerPointerEnteredEventArgs>


MapElementPointerExited event : TypedEventHandler<MapElementsLayer,MapElementsLayerPointerExitedEventArgs>


MapElements { get; set; } : IList<MapElement>


MapElementsProperty static { get; } : DependencyProperty



Location { get; } : Geopoint


MapElements { get; } : IList<MapElement>


Position { get; } : Point



Location { get; } : Geopoint


MapElements { get; } : IReadOnlyList<MapElement>


Position { get; } : Point



Location { get; } : Geopoint


MapElement { get; } : MapElement


Position { get; } : Point



Location { get; } : Geopoint


MapElement { get; } : MapElement


Position { get; } : Point



MapTabIndex { get; set; } : Int32


MapTabIndexProperty static { get; } : DependencyProperty


Visible { get; set; } : Boolean


VisibleProperty static { get; } : DependencyProperty


ZIndex { get; set; } : Int32


ZIndexProperty static { get; } : DependencyProperty



CreateFrom3MFAsync(IRandomAccessStreamReference source) static : IAsyncOperation<MapModel3D>


CreateFrom3MFAsync(IRandomAccessStreamReference source, MapModel3DShadingOption shadingOption) static : IAsyncOperation<MapModel3D>



Default : 0,


Flat : 1,


Smooth : 2,



AdminDistrict static { get; } : String


AdminDistrictCapital static { get; } : String


Airport static { get; } : String


Area static { get; } : String


ArterialRoad static { get; } : String


Building static { get; } : String


Business static { get; } : String


Capital static { get; } : String


Cemetery static { get; } : String


Continent static { get; } : String


ControlledAccessHighway static { get; } : String


CountryRegion static { get; } : String


CountryRegionCapital static { get; } : String


District static { get; } : String


DrivingRoute static { get; } : String


Education static { get; } : String


EducationBuilding static { get; } : String


FoodPoint static { get; } : String


Forest static { get; } : String


GolfCourse static { get; } : String


HighSpeedRamp static { get; } : String


Highway static { get; } : String


IndigenousPeoplesReserve static { get; } : String


Island static { get; } : String


MajorRoad static { get; } : String


Medical static { get; } : String


MedicalBuilding static { get; } : String


Military static { get; } : String


NaturalPoint static { get; } : String


Nautical static { get; } : String


Neighborhood static { get; } : String


Park static { get; } : String


Peak static { get; } : String


PlayingField static { get; } : String


Point static { get; } : String


PointOfInterest static { get; } : String


Political static { get; } : String


PopulatedPlace static { get; } : String


Railway static { get; } : String


Ramp static { get; } : String


Reserve static { get; } : String


River static { get; } : String


Road static { get; } : String


RoadExit static { get; } : String


RoadShield static { get; } : String


RouteLine static { get; } : String


Runway static { get; } : String


Sand static { get; } : String


ShoppingCenter static { get; } : String


Stadium static { get; } : String


Street static { get; } : String


Structure static { get; } : String


TollRoad static { get; } : String


Trail static { get; } : String


Transit static { get; } : String


TransitBuilding static { get; } : String


Transportation static { get; } : String


UnpavedStreet static { get; } : String


Vegetation static { get; } : String


VolcanicPeak static { get; } : String


WalkingRoute static { get; } : String


Water static { get; } : String


WaterPoint static { get; } : String


WaterRoute static { get; } : String



Default static { get; } : String


Disabled static { get; } : String


Hover static { get; } : String


Selected static { get; } : String




TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args) : Void



PlaceholderForeground { get; set; } : Brush


PlaceholderForegroundProperty static { get; } : DependencyProperty



ShowAsync(ContentDialogPlacement placement) : IAsyncOperation<ContentDialogResult>



Popup : 0,


InPlace : 1,



None : 0,


Bold : 1,


Italic : 2,


Underline : 4,


All : 4294967295,



ColumnSpacing { get; set; } : Double


ColumnSpacingProperty static { get; } : DependencyProperty


RowSpacing { get; set; } : Double


RowSpacingProperty static { get; } : DependencyProperty



Normal : 0,


Lower : 1,


Upper : 2,



InteractionTrackerAnimation(UIElement refreshVisualizer, UIElement infoProvider, InteractionTracker interactionTracker) : Void


RefreshCompletedAnimation(UIElement refreshVisualizer, UIElement infoProvider) : Void


RefreshRequestedAnimation(UIElement refreshVisualizer, UIElement infoProvider, Double executionRatio) : Void



InteractingForRefreshChanged event : TypedEventHandler<IRefreshInfoProvider,Object>


IsInteractingForRefreshChanged event : EventHandler<Object>


RefreshCompleted event : EventHandler<Object>


RefreshStarted event : EventHandler<Object>



AdaptFromTree(UIElement root, Size visualizerSize) : IRefreshInfoProvider


SetAnimations(UIElement refreshVisualizerAnimatableContainer) : Void


IsTextTrimmedChangedEventArgs



Hide() : Void


IsRepeatButtonVisible { get; set; } : Boolean


IsRepeatButtonVisibleProperty static { get; } : DependencyProperty


IsRepeatEnabled { get; set; } : Boolean


IsRepeatEnabledProperty static { get; } : DependencyProperty


Show() : Void


ShowAndHideAutomatically { get; set; } : Boolean


ShowAndHideAutomaticallyProperty static { get; } : DependencyProperty


NavigationMenuItem


NavigationMenuItemAutomationPeer


NavigationMenuItemBase


NavigationMenuItemBaseObservableCollection


NavigationMenuItemSeparator



AutoSuggestBox { get; set; } : AutoSuggestBox


AutoSuggestBoxProperty static { get; } : DependencyProperty


ContainerFromItem(Object item) : DependencyObject


ItemContainerStyleSelector { get; set; } : StyleSelector


ItemContainerStyleSelectorProperty static { get; } : DependencyProperty


ItemFromContainer(DependencyObject container) : Object


ItemTemplateSelector { get; set; } : DataTemplateSelector


ItemTemplateSelectorProperty static { get; } : DependencyProperty


MenuItems { get; } : IList<NavigationMenuItemBase>


MenuItems { get; } : IList<Object>


SelectedItem { get; set; } : Object


SelectedItemProperty static { get; } : DependencyProperty


SelectionChanged event : TypedEventHandler<NavigationView,SelectionChangedEventArgs>


SettingsInvoked event : TypedEventHandler<NavigationView,Object>


SettingsItem { get; } : Object


SettingsItemProperty static { get; } : DependencyProperty



CompactPaneLength { get; } : Double



ctor(NavigationViewItem owner)



Icon { get; set; } : IconElement


IconProperty static { get; } : DependencyProperty


ItemType { get; set; } : NavigationViewItemType


ItemTypeProperty static { get; } : DependencyProperty


Text { get; set; } : String


TextProperty static { get; } : DependencyProperty



Default : 0,


Separator : 1,


Header : 2,


NavigationViewList



PasswordChanging event : TypedEventHandler<PasswordBox,PasswordBoxPasswordChangingEventArgs>



IsContentChanging { get; } : Boolean



Caption { get; set; } : String


CaptionProperty static { get; } : DependencyProperty


InitialSetValue { get; set; } : Int32


InitialSetValueProperty static { get; } : DependencyProperty


IsClearEnabled { get; set; } : Boolean


IsClearEnabledProperty static { get; } : DependencyProperty


IsReadOnly { get; set; } : Boolean


IsReadOnlyProperty static { get; } : DependencyProperty


MaxRating { get; set; } : Int32


MaxRatingProperty static { get; } : DependencyProperty


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


PlaceholderValueProperty static { get; } : DependencyProperty


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


ValueChanged event : TypedEventHandler<RatingControl,Object>


ValueProperty static { get; } : DependencyProperty



ctor(RatingControl owner)


RatingsControl


RatingsControlAutomationPeer



RefreshInfoProviderAdapter { get; set; } : IRefreshInfoProviderAdapter


RefreshInfoProviderAdapterProperty static { get; } : DependencyProperty


RefreshRequested() : Void


RefreshVisualizer { get; set; } : RefreshVisualizer


RefreshVisualizerLocation { get; set; } : RefreshVisualizerLocation


RefreshVisualizerLocationProperty static { get; } : DependencyProperty


RefreshVisualizerProperty static { get; } : DependencyProperty



Left : 0,


Top : 1,


Right : 2,


Bottom : 3,



CopyingToClipboard event : TypedEventHandler<RichEditBox,TextControlCopyingToClipboardEventArgs>


CuttingToClipboard event : TypedEventHandler<RichEditBox,TextControlCuttingToClipboardEventArgs>


DisabledFormattingAccelerators { get; set; } : DisabledFormattingAccelerators


DisabledFormattingAcceleratorsProperty static { get; } : DependencyProperty


HorizontalTextAlignment { get; set; } : TextAlignment


HorizontalTextAlignmentProperty static { get; } : DependencyProperty


CharacterCasing { get; set; } : CharacterCasing


CharacterCasingProperty static { get; } : DependencyProperty



HorizontalTextAlignment { get; set; } : TextAlignment


HorizontalTextAlignmentProperty static { get; } : DependencyProperty


IsTextTrimmed { get; } : Boolean


IsTextTrimmedChanged event : TypedEventHandler<RichTextBlock,IsTextTrimmedChangedEventArgs>


IsTextTrimmedProperty static { get; } : DependencyProperty


TextHighlighters { get; } : IList<TextHighlighter>



IsTextTrimmed { get; } : Boolean


IsTextTrimmedChanged event : TypedEventHandler<RichTextBlockOverflow,IsTextTrimmedChangedEventArgs>


IsTextTrimmedProperty static { get; } : DependencyProperty



Adapt(ScrollViewer adaptee, Size visualizerSize) : IRefreshInfoProvider


AdaptFromTree(UIElement root, Size visualizerSize) : IRefreshInfoProvider


ctor(RefreshVisualizerLocation refreshVisualizerLocation, IAdapterAnimationHandler animationHandler)


SetAnimations(UIElement refreshVisualizerAnimatableContainer) : Void



Spacing { get; set; } : Double


SpacingProperty static { get; } : DependencyProperty



HorizontalTextAlignment { get; set; } : TextAlignment


HorizontalTextAlignmentProperty static { get; } : DependencyProperty


IsTextTrimmed { get; } : Boolean


IsTextTrimmedChanged event : TypedEventHandler<TextBlock,IsTextTrimmedChangedEventArgs>


IsTextTrimmedProperty static { get; } : DependencyProperty


TextHighlighters { get; } : IList<TextHighlighter>



BeforeTextChanging event : TypedEventHandler<TextBox,TextBoxBeforeTextChangingEventArgs>


CopyingToClipboard event : TypedEventHandler<TextBox,TextControlCopyingToClipboardEventArgs>


CuttingToClipboard event : TypedEventHandler<TextBox,TextControlCuttingToClipboardEventArgs>


HorizontalTextAlignment { get; set; } : TextAlignment


HorizontalTextAlignmentProperty static { get; } : DependencyProperty


CharacterCasing { get; set; } : CharacterCasing


CharacterCasingProperty static { get; } : DependencyProperty


PlaceholderForeground { get; set; } : Brush


PlaceholderForegroundProperty static { get; } : DependencyProperty



Cancel { get; set; } : Boolean


NewText { get; } : String



Handled { get; set; } : Boolean



Handled { get; set; } : Boolean



RootNodeProperty static { get; } : DependencyProperty


SelectAll() : Void


SelectedItems { get; } : IList<Object>


SelectionMode { get; set; } : TreeViewSelectionMode


SelectionModeProperty static { get; } : DependencyProperty



None : 0,


Single : 1,


Multiple : 2,




HorizontalTextAlignment { get; set; } : TextAlignment


HorizontalTextAlignmentProperty static { get; } : DependencyProperty



Background { get; set; } : Brush


BackgroundProperty static { get; } : DependencyProperty


Foreground { get; set; } : Brush


ForegroundProperty static { get; } : DependencyProperty


Ranges { get; } : IList<TextRange>


TextHighlighterBase



Length : Int32


StartIndex : Int32




AppUserModelId { get; } : String


CreateNewViewAsync(DesignerAppViewState initialViewState, Size initialViewSize) : IAsyncOperation<DesignerAppView>


ctor(String appUserModelId)


Dispose() : Void


DuplicateHandleIntoApp(UInt64 handle, Boolean inheritable) : UInt64


LoadObjectIntoAppAsync(String dllName, Guid classId, String initializationData) : IAsyncAction


ProcessExited event : TypedEventHandler<DesignerAppManager,ProcessExitedEventArgs>



ApplicationViewId { get; } : Int32


AppUserModelId { get; } : String


Dispose() : Void


UpdateViewAsync(DesignerAppViewState viewState, Size viewSize) : IAsyncAction


ViewSize { get; } : Size


ViewState { get; } : DesignerAppViewState



Visible : 0,


Hidden : 1,



ExitCode { get; } : UInt32




Handled { get; set; } : Boolean


Character { get; } : Char


KeyStatus { get; } : CorePhysicalKeyStatus



Invoked event : TypedEventHandler<KeyboardAccelerator,KeyboardAcceleratorInvokedEventArgs>


IsEnabled { get; set; } : Boolean


IsEnabledProperty static { get; } : DependencyProperty


Key { get; set; } : VirtualKey


KeyProperty static { get; } : DependencyProperty


Modifiers { get; set; } : VirtualKeyModifiers


ModifiersProperty static { get; } : DependencyProperty


ScopeOwner { get; set; } : DependencyObject


ScopeOwnerProperty static { get; } : DependencyProperty



Element { get; } : DependencyObject


Handled { get; set; } : Boolean



Handled { get; set; } : Boolean


Key { get; } : VirtualKey


Modifiers { get; } : VirtualKeyModifiers



ActualTheme { get; } : ElementTheme


ActualThemeChanged event : TypedEventHandler<FrameworkElement,Object>


ActualThemeProperty static { get; } : DependencyProperty



CharacterReceived event : TypedEventHandler<UIElement,CharacterReceivedRoutedEventArgs>


CharacterReceivedEvent static { get; } : RoutedEvent


KeyboardAccelerators { get; } : IList<KeyboardAccelerator>


ProcessKeyboardAccelerators event : TypedEventHandler<UIElement,ProcessKeyboardAcceleratorEventArgs>


TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args) : Void




InsufficientRangeSupport : 22,


MissingContentLengthSupport : 23,